pi-l1-cache 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tobias Weiß
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,160 @@
+# pi-l1-cache
+
+> **L1 In-Memory Cache Extension for pi** — CPU/RAM optimized, production-ready
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Pi Package](https://img.shields.io/badge/pi-package-blue)](https://pi.dev/packages)
+
+A high-performance, production-ready **L1 (in-memory) cache** extension for the [pi coding agent](https://pi.dev). Designed for stoic Unix simplicity: one file, one purpose, zero dependencies.
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **~0.1ms lookup** | FNV-1a fast hash — ~100× faster than SHA256 |
+| **Memory cap** | Hard limit (20MB default) prevents RAM bloat |
+| **Auto-eviction** | LRU-style cleanup when limits reached |
+| **CPU-aware** | Auto-disables when CPU > 95% |
+| **TTL-based** | 1-hour default expiry for cached entries |
+| **Atomic cleanup** | Periodic expired entry removal |
+
+## Architecture
+
+```
+pi → [L1: RAM Map] → [L2: Redis via LiteLLM] → Provider
+     <0.5ms          ~150ms                   1-3s
+```
+
+## Installation
+
+```bash
+# From npm (recommended)
+pi install npm:pi-l1-cache
+
+# From GitHub
+pi install git:github.com/tobias-weiss-ai-xr/pi-l1-cache@main
+
+# From local clone
+pi install /path/to/pi-l1-cache
+```
+
+Then **restart pi** — the extension auto-loads.
+
+## Usage
+
+```bash
+# Show cache stats
+/l1-cache
+
+# Show detailed stats
+/l1-cache stats
+
+# Clear cache
+/l1-cache clear
+
+# Enable cache (if disabled)
+/l1-cache enable
+
+# Disable cache (if enabled)
+/l1-cache disable
+```
+
+### Stats Output
+
+```
+L1 cache status: ENABLED
+Entries: 47 / 200
+Memory: 4.2MB / 20MB
+TTL: 3600s | CPU threshold: 95%
+Hits: 23 | Misses: 70 | Evictions: 5
+Hit rate: 24.7%
+Init CPU: 45.2% (ok)
+Last cleanup: 2025-08-22T10:30:00.000Z
+```
+
+## Configuration
+
+### Environment Variables
+
+Change defaults without modifying source code:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `L1_CACHE_ENABLED` | `true` | Master enable/disable |
+| `L1_CACHE_MAX_ENTRIES` | `200` | Maximum number of cache entries |
+| `L1_CACHE_MAX_MB` | `20` | Maximum memory in MB |
+| `L1_CACHE_TTL` | `3600` | TTL in seconds (1 hour) |
+| `L1_CACHE_LOG` | `false` | Enable debug logging |
+
+Example:
+```bash
+# Disable cache
+L1_CACHE_ENABLED=false pi
+
+# Use 50MB cache with 30-minute TTL
+L1_CACHE_MAX_MB=50 L1_CACHE_TTL=1800 pi
+```
+
+### Default Settings
+
+Edit `src/index.ts` (lines 30-38) to change compiled-in defaults:
+
+```typescript
+const DEFAULTS: Settings = {
+  enabled: true,
+  maxEntries: 200,
+  maxMemoryBytes: 20 * 1024 * 1024, // 20MB
+  ttlSeconds: 3600,                // 1 hour
+  cpuThreshold: 95,                 // disable if CPU > 95%
+  logStats: false,
+}
+```
+
+## Design Philosophy
+
+### Stoic Unix Principles
+- **One thing, done well** — Caching, and only caching
+- **Do not rely on external services** — Pure in-memory, no Redis
+- **Graceful degradation** — Works even on constrained systems
+- **Zero dependencies** — Single TypeScript file
+
+### Performance Optimizations
+1. **Fast string hashing** (FNV-1a) instead of SHA256
+2. **L1 only** — avoid disk I/O in hot path
+3. **Batch eviction** — remove 10-20% at a time, not one-by-one
+4. **Periodic cleanup** — async, non-blocking garbage collection
+5. **Single CPU check** — at startup only, not per-request
+
+## Testing
+
+```bash
+# Run all tests
+npm test
+
+# Watch mode
+npm run test:watch
+
+# Check TypeScript
+npx tsc --noEmit
+```
+
+17 tests covering:
+- Hash consistency & collision resistance
+- Size estimation for various data types
+- LRU eviction behavior (entry count + memory)
+- State management & reset
+- Settings override
+
+## Related Projects
+
+- **[opencode-saia-plugin](https://github.com/tobias-weiss-ai-xr/opencode-saia-plugin)** — SAIA provider for OpenCode
+- **[zot-saia-plugin](https://github.com/tobias-weiss-ai-xr/zot-saia-plugin)** — SAIA provider for zot CLI
+- **[pi-saia-plugin](https://github.com/tobias-weiss-ai-xr/pi-saia-plugin)** — SAIA provider for pi coding agent
+
+## License
+
+MIT — see [LICENSE](LICENSE)
+
+## Maintainer
+
+[Tobias Weiß](https://github.com/tobias-weiss-ai-xr) — weissto@hrz.uni-marburg.de

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "pi-l1-cache",
+  "version": "1.2.0",
+  "description": "L1 in-memory cache extension for pi — CPU/RAM optimized, production-ready",
+  "type": "module",
+  "main": "./src/index.ts",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "pi-package",
+    "extension",
+    "cache",
+    "performance",
+    "L1",
+    "memory",
+    "caching"
+  ],
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "author": "Tobias Weiß <weissto@hrz.uni-marburg.de>",
+  "license": "MIT",
+  "homepage": "https://github.com/tobias-weiss-ai-xr/pi-l1-cache",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tobias-weiss-ai-xr/pi-l1-cache.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tobias-weiss-ai-xr/pi-l1-cache/issues"
+  },
+  "pi": {
+    "extensions": ["./src/index.ts"],
+    "minPiVersion": "0.4.0"
+  },
+  "scripts": {
+    "test": "node --test src/*.test.ts",
+    "test:watch": "node --watch --test src/*.test.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, beforeEach } from "node:test"
+import assert from "node:assert/strict"
+import { _testHooks } from "./index.ts"
+
+const Test = _testHooks()
+
+describe("pi-l1-cache", () => {
+  describe("fastHash", () => {
+    it("returns consistent hash for same input", () => {
+      const input = "test-string-123"
+      assert.equal(Test.fastHash(input), Test.fastHash(input))
+    })
+
+    it("returns different hash for different input", () => {
+      assert.notEqual(Test.fastHash("hello"), Test.fastHash("world"))
+    })
+
+    it("handles empty string", () => {
+      const empty = Test.fastHash("")
+      assert.ok(empty.length > 0)
+    })
+
+    it("handles unicode", () => {
+      const emoji = Test.fastHash("🎉 pi-l1-cache 🎉")
+      assert.ok(emoji.length > 0)
+    })
+
+    it("is deterministic", () => {
+      const obj = JSON.stringify({ a: 1, b: 2 })
+      assert.equal(Test.fastHash(obj), Test.fastHash(obj))
+    })
+  })
+
+  describe("estimateSize", () => {
+    it("estimates size of simple strings", () => {
+      const size = Test.estimateSize("hello world")
+      assert.ok(size > 0)
+      assert.ok(size < 100)
+    })
+
+    it("estimates size of objects", () => {
+      const obj = { a: 1, b: "test", c: [1, 2, 3] }
+      const size = Test.estimateSize(obj)
+      assert.ok(size > 0)
+    })
+
+    it("estimates size of arrays", () => {
+      const arr = new Array(100).fill("x")
+      const size = Test.estimateSize(arr)
+      assert.ok(size > 100)
+    })
+
+    it("returns fallback for non-serializable", () => {
+      const circular: any = { a: 1 }
+      circular.self = circular
+      const size = Test.estimateSize(circular)
+      assert.equal(size, 1024)
+    })
+
+    it("handles null and undefined", () => {
+      assert.ok(Test.estimateSize(null) > 0)
+      assert.ok(Test.estimateSize(undefined) > 0)
+    })
+  })
+
+  describe("eviction logic", () => {
+    beforeEach(() => {
+      Test.reset()
+      Test.setSettings({ maxEntries: 10, maxMemoryBytes: 10000 })
+    })
+
+    it("evicts oldest entries first", () => {
+      for (let i = 0; i < 15; i++) {
+        Test._setCache(`key-${i}`, { response: {}, timestamp: i * 1000, sizeBytes: 100 })
+      }
+      Test.evictIfNeeded()
+      assert.ok(Test._getCacheSize() <= 10)
+    })
+
+    it("evicts by memory when full", () => {
+      Test.setSettings({ maxEntries: 1000, maxMemoryBytes: 1000 })
+      Test.reset()
+      for (let i = 0; i < 5; i++) {
+        Test._setCache(`key-${i}`, { response: new Array(100).fill("x"), timestamp: Date.now(), sizeBytes: 200 })
+      }
+      Test.evictIfNeeded()
+      assert.ok(Test._getTotalMemory() > 0)
+      assert.ok(Test._getTotalMemory() <= 1500)
+    })
+
+    it("evictIfNeeded enforces limits", () => {
+      for (let i = 0; i < 20; i++) {
+        Test._setCache(`key-${i}`, { response: {}, timestamp: i, sizeBytes: 100 })
+      }
+      Test.evictIfNeeded()
+      const after = Test._getCacheSize()
+      assert.ok(after <= 10)
+    })
+
+    it("evictOldest removes specified count", () => {
+      for (let i = 0; i < 10; i++) {
+        Test._setCache(`key-${i}`, { response: {}, timestamp: i * 1000, sizeBytes: 100 })
+      }
+      Test.evictOldest(3)
+      assert.equal(Test._getCacheSize(), 7)
+    })
+  })
+
+  describe("state management", () => {
+    beforeEach(() => {
+      Test.reset()
+      Test.setSettings({ maxEntries: 100, maxMemoryBytes: 1000000, ttlSeconds: 3600 })
+    })
+
+    it("returns correct state after adding entries", () => {
+      Test._setCache("k1", { response: {}, timestamp: Date.now(), sizeBytes: 100 })
+      Test._setCache("k2", { response: {}, timestamp: Date.now(), sizeBytes: 100 })
+      assert.equal(Test._getCacheSize(), 2)
+      assert.ok(Test._getTotalMemory() > 0)
+    })
+
+    it("reset clears all state", () => {
+      Test._setCache("k1", { response: {}, timestamp: Date.now(), sizeBytes: 100 })
+      Test.reset()
+      assert.equal(Test._getCacheSize(), 0)
+      assert.equal(Test._getTotalMemory(), 0)
+    })
+
+    it("setSettings works", () => {
+      Test.setSettings({ maxEntries: 999, maxMemoryBytes: 999999 })
+      const state = Test.getState()
+      assert.equal(state.settings.maxEntries, 999)
+      assert.equal(state.settings.maxMemoryBytes, 999999)
+    })
+  })
+})

package/src/index.ts

@@ -0,0 +1,320 @@
+// L1 Cache Extension — in-memory response cache for pi
+//
+// Stoic Unix principle: One thing, done well.
+// Optimized for minimal CPU/RAM overhead.
+//
+// Architecture:
+//   pi → [L1: RAM Map] → [L2: Redis via LiteLLM] → Provider
+//   Lookup: ~0.1ms  (vs 150ms Redis, 1-3s API)
+//
+// Design goals:
+//   - Fast string hash (FNV-1a) — ~100x faster than SHA256
+//   - Hard memory cap — never lets RAM bloat
+//   - TTL + LRU eviction
+//   - CPU-aware graceful degradation
+//   - Zero dependencies, single file
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface CacheEntry {
+  response: unknown
+  timestamp: number
+  sizeBytes: number
+}
+
+interface Settings {
+  enabled: boolean
+  maxEntries: number
+  maxMemoryBytes: number
+  ttlSeconds: number
+  cpuThreshold: number
+  logStats: boolean
+}
+
+interface Stats {
+  hits: number
+  misses: number
+  evictions: number
+  cpuSkips: number
+}
+
+// ---------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------
+
+const DEFAULTS: Settings = {
+  enabled: true,
+  maxEntries: 200,
+  maxMemoryBytes: 20 * 1024 * 1024, // 20MB
+  ttlSeconds: 3600,
+  cpuThreshold: 95,
+  logStats: false,
+}
+
+// Users can override via environment variables (highest priority)
+function envSettings(): Partial<Settings> {
+  const out: Partial<Settings> = {}
+  if (process.env.L1_CACHE_ENABLED !== undefined) out.enabled = process.env.L1_CACHE_ENABLED !== "false"
+  if (process.env.L1_CACHE_MAX_ENTRIES) out.maxEntries = parseInt(process.env.L1_CACHE_MAX_ENTRIES, 10) || DEFAULTS.maxEntries
+  if (process.env.L1_CACHE_MAX_MB) out.maxMemoryBytes = (parseInt(process.env.L1_CACHE_MAX_MB, 10) || 20) * 1024 * 1024
+  if (process.env.L1_CACHE_TTL) out.ttlSeconds = parseInt(process.env.L1_CACHE_TTL, 10) || DEFAULTS.ttlSeconds
+  if (process.env.L1_CACHE_LOG) out.logStats = process.env.L1_CACHE_LOG === "true"
+  return out
+}
+
+const settings: Settings = { ...DEFAULTS, ...envSettings() }
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+
+let cache = new Map<string, CacheEntry>()
+let totalMemory = 0
+let initialCpuLoad = 0
+let initialCpuStatus: "ok" | "disabled" | "error" = "ok"
+let lastCleanup = Date.now()
+const stats: Stats = { hits: 0, misses: 0, evictions: 0, cpuSkips: 0 }
+
+// ---------------------------------------------------------------------------
+// Core helpers
+// ---------------------------------------------------------------------------
+
+/** Fast string hash (FNV-1a) — ~100x faster than SHA256, enough for cache keys */
+function fastHash(str: string): string {
+  let hash = 2166136261
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i)
+    hash = Math.imul(hash, 16777619)
+  }
+  return hash.toString(16)
+}
+
+/** Estimate in-memory size of an arbitrary object (UTF-16 overhead ×2) */
+function estimateSize(obj: unknown): number {
+  try {
+    const json = JSON.stringify(obj)
+    if (json === undefined) return 64 // undefined/unserializable primitive
+    return json.length * 2
+  } catch {
+    return 1024 // fallback for non-serializable
+  }
+}
+
+function log(...args: unknown[]) {
+  if (settings.logStats) console.log("[l1-cache]", ...args)
+}
+
+// ---------------------------------------------------------------------------
+// Eviction
+// ---------------------------------------------------------------------------
+
+function evictOldest(count: number) {
+  if (count <= 0) return
+  const sorted = Array.from(cache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp)
+  for (let i = 0; i < Math.min(count, sorted.length); i++) {
+    const [key, entry] = sorted[i]
+    totalMemory -= entry.sizeBytes
+    cache.delete(key)
+    stats.evictions++
+  }
+}
+
+/** Enforce size and memory caps using LRU-style (oldest-first) eviction */
+function evictIfNeeded() {
+  while (cache.size > settings.maxEntries) {
+    evictOldest(Math.max(1, Math.ceil(settings.maxEntries * 0.1)))
+  }
+  while (totalMemory > settings.maxMemoryBytes) {
+    evictOldest(Math.max(1, Math.ceil(settings.maxEntries * 0.2)))
+  }
+}
+
+/** Remove expired entries (called periodically + on access) */
+function cleanupExpired() {
+  const now = Date.now()
+  let expired = 0
+  for (const [key, entry] of cache.entries()) {
+    if (now - entry.timestamp > settings.ttlSeconds * 1000) {
+      totalMemory -= entry.sizeBytes
+      cache.delete(key)
+      expired++
+    }
+  }
+  if (expired > 0) log(`expired ${expired} entries`)
+  lastCleanup = now
+}
+
+// ---------------------------------------------------------------------------
+// CPU check (once at startup — not per-request, to avoid overhead)
+// ---------------------------------------------------------------------------
+
+async function checkInitialCpuLoad(): Promise<number> {
+  try {
+    const { execSync } = await import("child_process")
+    if (process.platform === "win32") {
+      const out = execSync("wmic cpu get loadpercentage /value", { encoding: "utf8", timeout: 2000 })
+      const match = out.match(/LoadPercentage\s*:\s*(\d+)/)
+      return match ? parseInt(match[1], 10) : 0
+    }
+    const out = execSync("cat /proc/loadavg", { encoding: "utf8", timeout: 2000 })
+    const { cpus } = await import("os")
+    const cores = cpus().length
+    const load = parseFloat(out.split(" ")[0])
+    return Math.min(100, (load / cores) * 100)
+  } catch {
+    return 0
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests (self-check on load — see also src/index.test.ts)
+// ---------------------------------------------------------------------------
+
+export function _testHooks() {
+  return {
+    fastHash,
+    estimateSize,
+    evictIfNeeded,
+    cleanupExpired,
+    evictOldest,
+    getStats: () => ({ ...stats }),
+    getState: () => ({ size: cache.size, totalMemory, settings: { ...settings } }),
+    reset: () => {
+      cache = new Map()
+      totalMemory = 0
+      stats.hits = 0
+      stats.misses = 0
+      stats.evictions = 0
+      stats.cpuSkips = 0
+    },
+    _setCache: (key: string, entry: CacheEntry) => {
+      cache.set(key, entry)
+      totalMemory += entry.sizeBytes
+    },
+    _getCacheSize: () => cache.size,
+    _getTotalMemory: () => totalMemory,
+    setSettings: (patch: Partial<Settings>) => Object.assign(settings, patch),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main plugin
+// ---------------------------------------------------------------------------
+
+export default async function (pi: ExtensionAPI) {
+  // Async init: check CPU once at startup
+  try {
+    initialCpuLoad = await checkInitialCpuLoad()
+    if (initialCpuLoad > settings.cpuThreshold) {
+      settings.enabled = false
+      initialCpuStatus = "disabled"
+      console.log(
+        `[l1-cache] disabled (CPU ${initialCpuLoad.toFixed(0)}% > ${settings.cpuThreshold}% threshold)`,
+      )
+    } else {
+      initialCpuStatus = "ok"
+      console.log(
+        `[l1-cache] enabled (max ${settings.maxEntries} entries, ${(settings.maxMemoryBytes / 1024 / 1024).toFixed(0)}MB, TTL ${settings.ttlSeconds}s)`,
+      )
+    }
+  } catch (err) {
+    initialCpuStatus = "error"
+    console.log(`[l1-cache] CPU check failed (${err}); continuing enabled`)
+  }
+
+  // Periodic cleanup (every 10 minutes)
+  const cleanupTimer = setInterval(cleanupExpired, 10 * 60 * 1000)
+  pi.on("session_shutdown", () => clearInterval(cleanupTimer))
+
+  // Interceptor: cache lookup before provider request
+  pi.on("before_provider_request", async (event, ctx) => {
+    if (!settings.enabled) return
+
+    const model = ctx.model?.id || "unknown"
+    const messages = event.messages || []
+    const params = event.parameters || {}
+
+    // Fast hash; no per-request CPU check to stay on the hot path
+    const key = fastHash(model + JSON.stringify(messages) + JSON.stringify(params))
+    const entry = cache.get(key)
+
+    if (entry && Date.now() - entry.timestamp <= settings.ttlSeconds * 1000) {
+      stats.hits++
+      return entry.response as never
+    }
+
+    // Miss — remember the key for after_provider_response
+    event._cacheKey = key
+    stats.misses++
+  })
+
+  // Interceptor: store response after provider finishes
+  pi.on("after_provider_response", async (event) => {
+    if (!settings.enabled) return
+    if (!event._cacheKey) return
+
+    const key = event._cacheKey as string
+    const response = event.response ?? event.choices ?? event
+    const size = estimateSize(response)
+
+    cache.set(key, { response, timestamp: Date.now(), sizeBytes: size })
+    totalMemory += size
+    evictIfNeeded()
+  })
+
+  // Commands
+  pi.registerCommand("l1-cache", {
+    description: "Show L1 cache stats, or use 'clear' to reset",
+    handler: async (args: string, ctx: ExtensionContext) => {
+      const arg = (args ?? "").trim()
+
+      if (arg === "clear") {
+        cache.clear()
+        totalMemory = 0
+        stats.hits = 0
+        stats.misses = 0
+        stats.evictions = 0
+        ctx.ui.notify("L1 cache cleared", "success")
+        return
+      }
+
+      if (arg === "stats" || arg === "") {
+        const hitRate =
+          stats.hits + stats.misses > 0 ? ((stats.hits / (stats.hits + stats.misses)) * 100).toFixed(1) : "0.0"
+        const lines = [
+          `L1 cache status: ${settings.enabled ? "ENABLED" : "disabled"}`,
+          `Entries: ${cache.size} / ${settings.maxEntries}`,
+          `Memory: ${(totalMemory / 1024 / 1024).toFixed(1)}MB / ${(settings.maxMemoryBytes / 1024 / 1024).toFixed(1)}MB`,
+          `TTL: ${settings.ttlSeconds}s | CPU threshold: ${settings.cpuThreshold}%`,
+          `Hits: ${stats.hits} | Misses: ${stats.misses} | Evictions: ${stats.evictions}`,
+          `Hit rate: ${hitRate}%`,
+          `Init CPU: ${initialCpuLoad.toFixed(1)}% (${initialCpuStatus})`,
+          `Last cleanup: ${new Date(lastCleanup).toISOString()}`,
+        ]
+        ctx.ui.notify(lines.join("\n"), "info")
+        return ""
+      }
+
+      if (arg === "enable") {
+        settings.enabled = true
+        ctx.ui.notify("L1 cache enabled", "success")
+        return
+      }
+
+      if (arg === "disable") {
+        settings.enabled = false
+        ctx.ui.notify("L1 cache disabled", "success")
+        return
+      }
+
+      ctx.ui.notify(`Unknown command: /l1-cache ${arg}\nUsage: /l1-cache [stats|clear|enable|disable]`, "error")
+      return ""
+    },
+  })
+
+  console.log("[l1-cache] ready. /l1-cache for stats.")
+}