chiitiler 1.24.3 → 1.25.0

package/README.md

@@ -192,19 +192,19 @@ retaining native renderer memory between requests.
 
 Chiitiler caches *source assets* (vector tiles, glyphs, sprites) — not final rasters — so cached data is reused across requests. Standard AWS / GCP credentials (`AWS_ACCESS_KEY_ID`, `GOOGLE_APPLICATION_CREDENTIALS`, etc.) are respected.
 
-The tile server adds a per-process memory front cache to `file`, `s3`, and `gcs`:
-by default, buffers are retained for 10 seconds from insertion, with an LRU limit of 64 MiB
-of buffer payloads (JavaScript overhead is additional). Reads promote backing-cache
-hits into memory; writes populate memory immediately and also write to the backing
-cache. `none` and `memory` keep their existing behavior. This affects sources that
-already use the cache, not direct `s3://`, `gs://`, or local source reads.
+The tile server adds a per-process memory front cache to every cache method, including
+`none` and `memory`: by default, buffers are retained for 10 seconds from insertion, with an
+LRU limit of 64 MiB of buffer payloads (JavaScript overhead is additional). It applies to
+every source (`http(s)://`, `s3://`, `gs://`, `file://`, `mbtiles://`, `pmtiles://`, `cog://`).
+Only `http(s)://` sources (including `pmtiles://http(s)://` tiles) are also stored in the
+backing cache; reads promote backing-cache hits into memory, and writes populate memory
+immediately and also write to the backing cache.
 
 Set `--front-cache-ttl-sec` / `CHIITILER_FRONT_CACHE_TTL_SEC` to a positive, finite number of seconds and
 `--front-cache-max-bytes` / `CHIITILER_FRONT_CACHE_MAX_BYTES` to a positive integer number of bytes to override
-these limits. CLI flags take precedence over environment variables. Setting either limit to `0` disables the front cache and uses the
-backing cache directly. Otherwise, invalid values stop startup when using `file`,
-`s3`, or `gcs`.
-These settings do not affect `none`, `memory`, or library callers.
+these limits. CLI flags take precedence over environment variables. Set either limit to `0`
+(e.g. `CHIITILER_FRONT_CACHE_TTL_SEC=0`) to disable the front cache entirely. Otherwise,
+invalid values stop startup. These settings do not affect library callers.
 
 The front-cache TTL does not guarantee source freshness: promotion can retain a
 value for up to the configured TTL beyond its backing-cache expiry, and the S3/GCS cache

package/dist/cache/front.js

@@ -23,6 +23,13 @@ export function withMemoryCache(backing, { ttlSeconds = 10, maxBytes = 64 * 1024
     const reads = new Map();
     return {
         name: backing.name,
+        memory: {
+            name: 'memory',
+            get: async (key) => memory.get(key),
+            set: async (key, value) => {
+                memory.set(key, value);
+            },
+        },
         get: async (key) => {
             const hit = memory.get(key);
             if (hit !== undefined)

package/dist/cache/index.d.ts

@@ -8,6 +8,8 @@ type Cache = {
     name: string;
     get: (key: string) => Promise<Value | undefined>;
     set: (key: string, value: Value) => Promise<void>;
+    /** Short-lived in-process layer (set by withMemoryCache), applied to every source. */
+    memory?: Cache;
 };
 declare const noneCache: () => Cache;
 export { noneCache, memoryCache, s3Cache, gcsCache, fileCache, type Value, type Cache };

package/dist/cli.js

@@ -149,14 +149,12 @@ export function createProgram() {
             port: parsePort(options.port),
             debug: parseDebug(options.debug),
         };
-        if (['file', 's3', 'gcs'].includes(serverOptions.cache.name)) {
-            const ttl = options.frontCacheTtlSec;
-            const size = options.frontCacheMaxBytes;
-            serverOptions.cache = caches.withMemoryCache(serverOptions.cache, {
-                ttlSeconds: ttl === undefined ? undefined : Number(ttl.trim() || NaN),
-                maxBytes: size === undefined ? undefined : Number(size.trim() || NaN),
-            });
-        }
+        const ttl = options.frontCacheTtlSec;
+        const size = options.frontCacheMaxBytes;
+        serverOptions.cache = caches.withMemoryCache(serverOptions.cache, {
+            ttlSeconds: ttl === undefined ? undefined : Number(ttl.trim() || NaN),
+            maxBytes: size === undefined ? undefined : Number(size.trim() || NaN),
+        });
         if (serverOptions.debug) {
             console.log(`running server: http://localhost:${serverOptions.port}`);
             console.log(`cache method: ${serverOptions.cache.name}`);

package/dist/source/http.js

@@ -3,7 +3,6 @@
 import { noneCache } from '../cache/index.js';
 import { getUserAgent } from './userAgent.js';
 async function getHttpSource(uri, cache = noneCache()) {
-    // use cache only for http(s) sources
     const val = await cache.get(uri);
     if (val !== undefined)
         return val; // hit

package/dist/source/index.d.ts

@@ -4,7 +4,7 @@ import { Cache } from '../cache/index.js';
  * Concurrent requests for the same uri share a single in-flight fetch
  * (single-flight) to avoid duplicate downloads.
  * @param uri
- * @param cache {Cache} - Cache Strategy. Affect only for http(s) sources.
+ * @param cache {Cache} - Cache Strategy. Its memory layer applies to every source; the backing cache only to http(s).
  * @returns
  */
 declare function getSource(uri: string, cache?: Cache): Promise<Buffer | null>;

package/dist/source/index.js

@@ -6,6 +6,20 @@ import { getS3Source } from './s3.js';
 import { getGCSSource } from './gcs.js';
 import { getCogSource } from './cog.js';
 import { noneCache } from '../cache/index.js';
+/**
+ * Every source reads through the short-lived in-process memory layer.
+ * Only http(s) sources also persist to the backing cache (in fetchSource).
+ * Empty results are not cached.
+ */
+async function cached(uri, { memory: cache = noneCache() }, load) {
+    const val = await cache.get(uri);
+    if (val !== undefined)
+        return val;
+    const buf = await load();
+    if (buf !== null && buf.length > 0)
+        cache.set(uri, buf);
+    return buf;
+}
 async function fetchSource(uri, cache) {
     if (uri.startsWith('http://') || uri.startsWith('https://'))
         return getHttpSource(uri, cache);
@@ -29,14 +43,14 @@ const inFlight = new Map();
  * Concurrent requests for the same uri share a single in-flight fetch
  * (single-flight) to avoid duplicate downloads.
  * @param uri
- * @param cache {Cache} - Cache Strategy. Affect only for http(s) sources.
+ * @param cache {Cache} - Cache Strategy. Its memory layer applies to every source; the backing cache only to http(s).
  * @returns
  */
 async function getSource(uri, cache = noneCache()) {
     const existing = inFlight.get(uri);
     if (existing !== undefined)
         return existing;
-    const promise = fetchSource(uri, cache).finally(() => {
+    const promise = cached(uri, cache, () => fetchSource(uri, cache)).finally(() => {
         inFlight.delete(uri);
     });
     inFlight.set(uri, promise);

package/package.json

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