chiitiler 1.17.0 → 1.19.0

package/README.md

@@ -119,10 +119,6 @@ Volumes mount `localdata/` and `.cache/` so test assets and cached source data p
 
 POST requests accept the style object directly in the JSON body (`{ "style": { ... } }`).
 
-### Streaming Responses
-
-Enable streaming (Sharp pipeline without buffering) by setting `CHIITILER_STREAM_MODE=true` or passing `--stream`.
-
 ## CLI Reference
 
 Chiitiler exposes a single command: `tile-server`.
@@ -147,7 +143,6 @@ npx tsx src/main.ts tile-server --help
 | `--gcs-cache-prefix <prefix>` | GCS object prefix. | `CHIITILER_GCS_CACHE_PREFIX` | `""` |
 | `--gcs-api-endpoint <url>` | Custom GCS endpoint. | `CHIITILER_GCS_API_ENDPOINT` | `""` |
 | `--port <number>` | HTTP listen port. | `CHIITILER_PORT` | `3000` |
-| `--stream` | Enable streaming mode. | `CHIITILER_STREAM_MODE` | `false` |
 | `--debug` | Enable debug UI routes. | `CHIITILER_DEBUG` | `false` |
 
 Set `CHIITILER_PROCESSES` to control clustering (`0` uses all CPUs). When `>1`, the primary process forks workers that all share the same cache adapter.
@@ -202,11 +197,11 @@ Chiitiler is also published as an npm library. Core helpers return Sharp instanc
 ```ts
 import {
     getRenderedTileBuffer,
-    getRenderedBboxBuffer,
-    getRenderedImageBuffer,
+    getRenderedClipBuffer,
+    getRenderedCameraBuffer,
     getRenderedTileStream,
-    getRenderedBboxStream,
-    getRenderedImageStream,
+    getRenderedClipStream,
+    getRenderedCameraStream,
     ChiitilerCache,
 } from 'chiitiler';
 
@@ -224,7 +219,7 @@ const tile = await getRenderedTileBuffer({
     cache,
 });
 
-const clip = await getRenderedBboxBuffer({
+const clip = await getRenderedClipBuffer({
     stylejson: 'file://localdata/style.json',
     bbox: [123.4, 34.5, 124.5, 35.6],
     size: 1024,
@@ -233,7 +228,7 @@ const clip = await getRenderedBboxBuffer({
     cache: ChiitilerCache.noneCache(),
 });
 
-const image = await getRenderedImageBuffer({
+const camera = await getRenderedCameraBuffer({
     stylejson: 'file://localdata/style.json',
     center: [139.69, 35.68],
     zoom: 10,
@@ -259,7 +254,7 @@ const tileStream = await getRenderedTileStream({
     cache,
 });
 
-const bboxStream = await getRenderedBboxStream({
+const clipStream = await getRenderedClipStream({
     stylejson: 'file://localdata/style.json',
     bbox: [123.4, 34.5, 124.5, 35.6],
     size: 1024,
@@ -268,7 +263,7 @@ const bboxStream = await getRenderedBboxStream({
     cache,
 });
 
-const imageStream = await getRenderedImageStream({
+const cameraStream = await getRenderedCameraStream({
     stylejson: 'file://localdata/style.json',
     center: [139.69, 35.68],
     zoom: 10,

package/dist/cli.js

@@ -81,17 +81,6 @@ function parseDebug(debug) {
     // undefined or invalid
     return false;
 }
-function parseStream(stream) {
-    // command-line option
-    if (stream)
-        return true;
-    // command-line is not specified or false -> try to read from env
-    const streamEnv = process.env.CHIITILER_STREAM_MODE;
-    if (streamEnv !== undefined)
-        return streamEnv === 'true';
-    // undefined or invalid
-    return false;
-}
 export function createProgram() {
     const program = new Command();
     program
@@ -110,7 +99,6 @@ export function createProgram() {
         .option('-gcsp --gcs-cache-prefix <prefix>', 'gcs cache prefix', '')
         .option('-gcse --gcs-api-endpoint <api-endpoint>', 'gcs api endpoint', '')
         .option('-p --port <port>', 'port number')
-        .option('-r --stream', 'stream mode')
         .option('-D --debug', 'debug mode')
         .action((options) => {
         const serverOptions = {
@@ -130,14 +118,12 @@ export function createProgram() {
             }),
             port: parsePort(options.port),
             debug: parseDebug(options.debug),
-            stream: parseStream(options.stream),
         };
         if (serverOptions.debug) {
             console.log(`running server: http://localhost:${serverOptions.port}`);
             console.log(`cache method: ${serverOptions.cache.name}`);
             console.log(`debug page: http://localhost:${serverOptions.port}/debug`);
             console.log(`editor page: http://localhost:${serverOptions.port}/editor`);
-            console.log('stream mode:', serverOptions.stream ? 'enabled' : 'disabled');
         }
         const { start } = initServer(serverOptions);
         start();

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { getRenderedBbox, getRenderedTile, getRenderedImage, GetRenderedBboxOptions, GetRenderedTileOptions, GetRenderedImageOptions } from './render/index.js';
-export declare function getRenderedBboxBuffer(options: GetRenderedBboxOptions): Promise<Buffer>;
-export { getRenderedBbox as getRenderedBboxStream };
-export declare function getRenderedImageBuffer(options: GetRenderedImageOptions): Promise<Buffer>;
-export { getRenderedImage as getRenderedImageStream };
+import { getRenderedClip, getRenderedTile, getRenderedCamera, GetRenderedClipOptions, GetRenderedTileOptions, GetRenderedCameraOptions } from './render/index.js';
+export declare function getRenderedClipBuffer(options: GetRenderedClipOptions): Promise<Buffer>;
+export { getRenderedClip as getRenderedClipStream };
+export declare function getRenderedCameraBuffer(options: GetRenderedCameraOptions): Promise<Buffer>;
+export { getRenderedCamera as getRenderedCameraStream };
 export declare function getRenderedTileBuffer(options: GetRenderedTileOptions): Promise<Buffer>;
 export { getRenderedTile as getRenderedTileStream };
 export * as ChiitilerCache from './cache/index.js';

package/dist/index.js

@@ -1,14 +1,14 @@
-import { getRenderedBbox, getRenderedTile, getRenderedImage, } from './render/index.js';
-export async function getRenderedBboxBuffer(options) {
-    const sharp = await getRenderedBbox(options);
+import { getRenderedClip, getRenderedTile, getRenderedCamera, } from './render/index.js';
+export async function getRenderedClipBuffer(options) {
+    const sharp = await getRenderedClip(options);
     return sharp.toBuffer();
 }
-export { getRenderedBbox as getRenderedBboxStream };
-export async function getRenderedImageBuffer(options) {
-    const sharp = await getRenderedImage(options);
+export { getRenderedClip as getRenderedClipStream };
+export async function getRenderedCameraBuffer(options) {
+    const sharp = await getRenderedCamera(options);
     return sharp.toBuffer();
 }
-export { getRenderedImage as getRenderedImageStream };
+export { getRenderedCamera as getRenderedCameraStream };
 export async function getRenderedTileBuffer(options) {
     const sharp = await getRenderedTile(options);
     return sharp.toBuffer();

package/dist/render/index.d.ts

@@ -14,7 +14,7 @@ type GetRenderedTileOptions = {
 };
 type SupportedFormat = 'png' | 'jpeg' | 'jpg' | 'webp';
 declare function getRenderedTile({ stylejson, z, x, y, tileSize, cache, margin, ext, quality, }: GetRenderedTileOptions): Promise<sharp.Sharp>;
-type GetRenderedBboxOptions = {
+type GetRenderedClipOptions = {
     stylejson: string | StyleSpecification;
     bbox: [number, number, number, number];
     size: number;
@@ -22,8 +22,8 @@ type GetRenderedBboxOptions = {
     ext: SupportedFormat;
     quality: number;
 };
-declare function getRenderedBbox({ stylejson, bbox, size, cache, ext, quality, }: GetRenderedBboxOptions): Promise<sharp.Sharp>;
-type GetRenderedImageOptions = {
+declare function getRenderedClip({ stylejson, bbox, size, cache, ext, quality, }: GetRenderedClipOptions): Promise<sharp.Sharp>;
+type GetRenderedCameraOptions = {
     stylejson: string | StyleSpecification;
     cache: Cache;
     ext: SupportedFormat;
@@ -35,5 +35,5 @@ type GetRenderedImageOptions = {
     height: number;
     width: number;
 };
-declare function getRenderedImage(options: GetRenderedImageOptions): Promise<sharp.Sharp>;
-export { getRenderedTile, getRenderedBbox, getRenderedImage, type GetRenderedBboxOptions, type GetRenderedTileOptions, type GetRenderedImageOptions, type SupportedFormat, };
+declare function getRenderedCamera(options: GetRenderedCameraOptions): Promise<sharp.Sharp>;
+export { getRenderedTile, getRenderedClip, getRenderedCamera, type GetRenderedClipOptions, type GetRenderedTileOptions, type GetRenderedCameraOptions, type SupportedFormat, };

package/dist/render/index.js

@@ -112,7 +112,7 @@ const calcRenderingParams = (bbox, size) => {
     const center = mercator.ll(mercCenter, 25); // latlon
     return { zoom, width, height, center };
 };
-async function getRenderedBbox({ stylejson, bbox, size, cache, ext, quality, }) {
+async function getRenderedClip({ stylejson, bbox, size, cache, ext, quality, }) {
     const style = await loadStyle(stylejson, cache);
     const { zoom, width, height, center } = calcRenderingParams(bbox, size);
     const pixels = await render(style, {
@@ -138,7 +138,7 @@ async function getRenderedBbox({ stylejson, bbox, size, cache, ext, quality, })
             return _sharp.webp({ quality, effort: 0 });
     }
 }
-async function getRenderedImage(options) {
+async function getRenderedCamera(options) {
     const style = await loadStyle(options.stylejson, options.cache);
     const pixels = await render(style, {
         center: options.center,
@@ -165,4 +165,4 @@ async function getRenderedImage(options) {
             return _sharp.webp({ quality: options.quality, effort: 0 });
     }
 }
-export { getRenderedTile, getRenderedBbox, getRenderedImage, };
+export { getRenderedTile, getRenderedClip, getRenderedCamera, };

package/dist/server/index.d.ts

@@ -4,7 +4,6 @@ type InitServerOptions = {
     cache: Cache;
     port: number;
     debug: boolean;
-    stream: boolean;
 };
 type InitializedServer = {
     app: Hono;

package/dist/server/index.js

@@ -13,15 +13,12 @@ function initServer(options) {
     hono.get('/health', (c) => c.text('OK'));
     hono.route('/camera', createCameraRouter({
         cache: options.cache,
-        stream: options.stream,
     }));
     hono.route('/tiles', createTilesRouter({
         cache: options.cache,
-        stream: options.stream,
     }));
     hono.route('/', createClipRouter({
         cache: options.cache,
-        stream: options.stream,
     }));
     return {
         app: hono,

package/dist/server/routes/camera.d.ts

@@ -1,7 +1,6 @@
 import { Cache } from '../../cache/index.js';
 declare function createCameraRouter(options: {
     cache: Cache;
-    stream: boolean;
 }): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {
     "/:zoom/:lat/:lon/:bearing/:pitch/:dimensions_ext": {
         $get: {
@@ -20,9 +19,104 @@ declare function createCameraRouter(options: {
                     dimensions_ext: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: import("hono/utils/http-status").StatusCode;
+            output: "invalid format";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: "url is required";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: Uint8Array<ArrayBuffer>;
+            outputFormat: "body";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: "invalid dimensions";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: "invalid camera";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: "failed to render static image";
+            outputFormat: "body";
+            status: 400;
         };
     };
 } & {
@@ -43,9 +137,104 @@ declare function createCameraRouter(options: {
                     dimensions_ext: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: import("hono/utils/http-status").StatusCode;
+            output: "invalid format";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: Uint8Array<ArrayBuffer>;
+            outputFormat: "body";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: "invalid dimensions";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: "invalid camera";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: "failed to render static image";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    zoom: string;
+                } & {
+                    lat: string;
+                } & {
+                    lon: string;
+                } & {
+                    bearing: string;
+                } & {
+                    pitch: string;
+                } & {
+                    dimensions_ext: string;
+                };
+            };
+            output: "invalid stylejson";
+            outputFormat: "body";
+            status: 400;
         };
     };
 }, "/", "/:zoom/:lat/:lon/:bearing/:pitch/:dimensions_ext">;

package/dist/server/routes/camera.js

@@ -1,7 +1,6 @@
 import { Hono } from 'hono';
-import { stream } from 'hono/streaming';
 import { isSupportedFormat, isValidStylejson } from '../utils.js';
-import { getRenderedImage } from '../../render/index.js';
+import { getRenderedCamera } from '../../render/index.js';
 function isValidCamera({ zoom, lat, lon, bearing, pitch, }) {
     if (Number.isNaN(lat) || lat < -90 || lat > 90)
         return false;
@@ -52,7 +51,7 @@ function createCameraRouter(options) {
         const quality = Number(c.req.query('quality') ?? 100);
         c.header('Content-Type', `image/${ext}`);
         try {
-            const sharp = await getRenderedImage({
+            const sharp = await getRenderedCamera({
                 stylejson: url,
                 cache: options.cache,
                 ext,
@@ -64,18 +63,8 @@ function createCameraRouter(options) {
                 height: _height,
                 width: _width,
             });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
+            const buf = await sharp.toBuffer();
+            return c.body(buf);
         }
         catch (e) {
             console.error(`render error: ${e}`);
@@ -115,7 +104,7 @@ function createCameraRouter(options) {
         const quality = Number(c.req.query('quality') ?? 100);
         c.header('Content-Type', `image/${ext}`);
         try {
-            const sharp = await getRenderedImage({
+            const sharp = await getRenderedCamera({
                 stylejson: style,
                 cache: options.cache,
                 ext,
@@ -127,18 +116,8 @@ function createCameraRouter(options) {
                 height: _height,
                 width: _width,
             });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
+            const buf = await sharp.toBuffer();
+            return c.body(buf);
         }
         catch (e) {
             console.error(`render error: ${e}`);

package/dist/server/routes/clip.d.ts

@@ -1,7 +1,6 @@
 import { Cache } from '../../cache/index.js';
 declare function createClipRouter(options: {
     cache: Cache;
-    stream: boolean;
 }): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {
     "/:filename_ext": {
         $get: {
@@ -10,9 +9,63 @@ declare function createClipRouter(options: {
                     filename_ext: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: import("hono/utils/http-status").StatusCode;
+            output: "invalid format";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "url is required";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: Uint8Array<ArrayBuffer>;
+            outputFormat: "body";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "failed to render tile";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "not found";
+            outputFormat: "body";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "bbox is required";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "invalid bbox";
+            outputFormat: "body";
+            status: 400;
         };
     };
 } & {
@@ -23,9 +76,63 @@ declare function createClipRouter(options: {
                     filename_ext: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: import("hono/utils/http-status").StatusCode;
+            output: "invalid format";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: Uint8Array<ArrayBuffer>;
+            outputFormat: "body";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "failed to render tile";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "not found";
+            outputFormat: "body";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "bbox is required";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "invalid bbox";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    filename_ext: string;
+                };
+            };
+            output: "invalid stylejson";
+            outputFormat: "body";
+            status: 400;
         };
     };
 }, "/", "/:filename_ext">;

package/dist/server/routes/clip.js

@@ -1,7 +1,6 @@
 import { Hono } from 'hono';
-import { stream } from 'hono/streaming';
 import { isSupportedFormat, isValidStylejson } from '../utils.js';
-import { getRenderedBbox } from '../../render/index.js';
+import { getRenderedClip } from '../../render/index.js';
 function createClipRouter(options) {
     const clip = new Hono()
         .get('/:filename_ext', async (c) => {
@@ -25,7 +24,7 @@ function createClipRouter(options) {
         const size = Number(c.req.query('size') ?? 1024);
         c.header('Content-Type', `image/${ext}`);
         try {
-            const sharp = await getRenderedBbox({
+            const sharp = await getRenderedClip({
                 stylejson: url,
                 bbox: [minx, miny, maxx, maxy],
                 size,
@@ -33,18 +32,8 @@ function createClipRouter(options) {
                 ext,
                 quality,
             });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
+            const buf = await sharp.toBuffer();
+            return c.body(buf);
         }
         catch (e) {
             console.error(`render error: ${e}`);
@@ -73,7 +62,7 @@ function createClipRouter(options) {
         const size = Number(c.req.query('size') ?? 1024);
         c.header('Content-Type', `image/${ext}`);
         try {
-            const sharp = await getRenderedBbox({
+            const sharp = await getRenderedClip({
                 stylejson: style,
                 bbox: [minx, miny, maxx, maxy],
                 size,
@@ -81,18 +70,8 @@ function createClipRouter(options) {
                 ext,
                 quality,
             });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
+            const buf = await sharp.toBuffer();
+            return c.body(buf);
         }
         catch (e) {
             console.error(`render error: ${e}`);

package/dist/server/routes/tiles.d.ts

@@ -1,7 +1,6 @@
 import { Cache } from '../../cache/index.js';
 declare function createTilesRouter(options: {
     cache: Cache;
-    stream: boolean;
 }): import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {
     "/:z/:x/:y_ext": {
         $get: {
@@ -14,9 +13,61 @@ declare function createTilesRouter(options: {
                     y_ext: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: import("hono/utils/http-status").StatusCode;
+            output: "invalid format";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    z: string;
+                } & {
+                    x: string;
+                } & {
+                    y_ext: string;
+                };
+            };
+            output: "url is required";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    z: string;
+                } & {
+                    x: string;
+                } & {
+                    y_ext: string;
+                };
+            };
+            output: Uint8Array<ArrayBuffer>;
+            outputFormat: "body";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    z: string;
+                } & {
+                    x: string;
+                } & {
+                    y_ext: string;
+                };
+            };
+            output: "failed to render tile";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    z: string;
+                } & {
+                    x: string;
+                } & {
+                    y_ext: string;
+                };
+            };
+            output: "invalid xyz";
+            outputFormat: "body";
+            status: 400;
         };
     };
 } & {
@@ -31,9 +82,61 @@ declare function createTilesRouter(options: {
                     y_ext: string;
                 };
             };
-            output: {};
-            outputFormat: string;
-            status: import("hono/utils/http-status").StatusCode;
+            output: "invalid format";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    z: string;
+                } & {
+                    x: string;
+                } & {
+                    y_ext: string;
+                };
+            };
+            output: Uint8Array<ArrayBuffer>;
+            outputFormat: "body";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        } | {
+            input: {
+                param: {
+                    z: string;
+                } & {
+                    x: string;
+                } & {
+                    y_ext: string;
+                };
+            };
+            output: "failed to render tile";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    z: string;
+                } & {
+                    x: string;
+                } & {
+                    y_ext: string;
+                };
+            };
+            output: "invalid xyz";
+            outputFormat: "body";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    z: string;
+                } & {
+                    x: string;
+                } & {
+                    y_ext: string;
+                };
+            };
+            output: "invalid stylejson";
+            outputFormat: "body";
+            status: 400;
         };
     };
 }, "/", "/:z/:x/:y_ext">;

package/dist/server/routes/tiles.js

@@ -1,5 +1,4 @@
 import { Hono } from 'hono';
-import { stream } from 'hono/streaming';
 import { isSupportedFormat, isValidStylejson } from '../utils.js';
 import { getRenderedTile } from '../../render/index.js';
 function isValidXyz(x, y, z) {
@@ -41,18 +40,8 @@ function createTilesRouter(options) {
                 ext,
                 quality,
             });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
+            const buf = await sharp.toBuffer();
+            return c.body(buf);
         }
         catch (e) {
             console.error(`render error: ${e}`);
@@ -90,18 +79,8 @@ function createTilesRouter(options) {
                 ext,
                 quality,
             });
-            if (options.stream) {
-                // stream mode
-                return stream(c, async (stream) => {
-                    for await (const chunk of sharp) {
-                        stream.write(chunk);
-                    }
-                });
-            }
-            else {
-                const buf = await sharp.toBuffer();
-                return c.body(buf);
-            }
+            const buf = await sharp.toBuffer();
+            return c.body(buf);
         }
         catch (e) {
             console.error(`render error: ${e}`);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "chiitiler",
-	"version": "1.17.0",
+	"version": "1.19.0",
 	"description": "Tiny map rendering server for MapLibre Style Spec",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",