codex-copilot-dx 0.4.35 → 0.4.36

package/src/anthropic-handler.mjs

@@ -0,0 +1,128 @@
+import {
+  anthropicToChat,
+  chatToAnthropic,
+  countTokens,
+  streamAnthropicFromLines,
+} from "./anthropic.mjs";
+import {
+  createRequestAbort,
+  logRequestFailure,
+  readJsonBody,
+  sendJsonError,
+  sendUpstreamError,
+  writeOrDrain,
+} from "./http-transport.mjs";
+import { resolveAnthropicModel } from "./models.mjs";
+import { status } from "./status.mjs";
+import { webStreamLines } from "./stream.mjs";
+import { endStreamWithError } from "./stream-errors.mjs";
+import { recordAnthropicUsage } from "./usage.mjs";
+
+export function createAnthropicCountTokensHandler(options) {
+  const { acquireRequest } = options;
+
+  return async function handleAnthropicCountTokens(req, res) {
+    const abort = createRequestAbort(req, res);
+    let releaseRequest = () => {};
+    try {
+      releaseRequest = await acquireRequest(req, { signal: abort.signal });
+      const parsed = await readJsonBody(req);
+      const result = await countTokens(parsed);
+      releaseRequest();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (error) {
+      sendJsonError(res, error);
+    } finally {
+      releaseRequest();
+      abort.cleanup();
+    }
+  };
+}
+
+export function createAnthropicMessagesHandler(options) {
+  const {
+    acquireRequest,
+    chatCompletionsFn,
+    environment,
+    modelOptions,
+    streamHandshakeTimeoutMs,
+    streamIdleTimeoutMs,
+    upstreamTimeoutMs,
+  } = options;
+
+  return async function handleAnthropicMessages(req, res) {
+    const abort = createRequestAbort(req, res);
+    let releaseRequest = () => {};
+    try {
+      releaseRequest = await acquireRequest(req, { signal: abort.signal });
+      const parsed = await readJsonBody(req);
+      abort.setTimeout(
+        parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
+        parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",
+      );
+      const { requestedModel, upstreamModel } = resolveAnthropicModel(parsed.model || "unknown", environment, modelOptions());
+      const modelNote = upstreamModel === requestedModel ? requestedModel : `${requestedModel} -> ${upstreamModel}`;
+      console.log(status("info", `messages model=${modelNote} stream=${!!parsed.stream}`));
+      const chatReq = anthropicToChat(parsed, { upstreamModel });
+      const forceRequestedModel = upstreamModel !== requestedModel;
+      if (parsed.stream) {
+        const upstream = await chatCompletionsFn({ ...chatReq, stream: true }, { signal: abort.signal });
+        releaseRequest();
+        if (!upstream.ok) {
+          if (!res.headersSent) res.writeHead(upstream.status);
+          res.end(await upstream.text());
+          return;
+        }
+        abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
+        res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+        let messageId;
+        let usage;
+        try {
+          await streamAnthropicFromLines(
+            webStreamLines(upstream, {
+              onChunk: () => abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout"),
+            }),
+            async (event, data) => {
+              if (event === "message_start") messageId = data.message?.id;
+              if (event === "message_delta") usage = data.usage;
+              await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            },
+            requestedModel,
+            { forceModel: forceRequestedModel },
+          );
+        } catch (error) {
+          logRequestFailure("Messages", error, abort);
+          await endStreamWithError(res, "anthropic", error, abort);
+          return;
+        }
+        recordAnthropicUsage({ surface: "messages", mode: "stream", model: requestedModel, responseId: messageId, usage });
+        if (!res.writableEnded) res.end();
+      } else {
+        const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
+        releaseRequest();
+        const data = await upstream.text();
+        if (!upstream.ok) {
+          sendUpstreamError(res, upstream, data);
+          return;
+        }
+        const anthropicMessage = chatToAnthropic(JSON.parse(data), requestedModel, { forceModel: forceRequestedModel });
+        recordAnthropicUsage({
+          surface: "messages",
+          mode: "json",
+          model: anthropicMessage.model,
+          responseId: anthropicMessage.id,
+          usage: anthropicMessage.usage,
+        });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(anthropicMessage));
+      }
+    } catch (error) {
+      logRequestFailure("Messages", error, abort);
+      sendJsonError(res, error, 502);
+    } finally {
+      releaseRequest();
+      abort.cleanup();
+    }
+  };
+}

package/src/anthropic.mjs

@@ -8,7 +8,7 @@ async function tokenCounter() {
 }
 
 // Anthropic Messages API to OpenAI chat/completions translation.
-// Pure functions only; network calls stay in adapter.mjs and copilot.mjs.
+// Pure functions only; network calls stay in the protocol handler and copilot.mjs.
 
 export function mapStopReason(finishReason) {
   switch (finishReason) {

package/src/auth.mjs

@@ -2,7 +2,12 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import {
+  githubIdentityMatchesExpected,
+  githubTokenFingerprint,
+  normalizeGithubIdentity,
+} from "./github-identity.mjs";
+import { parsePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 import { status } from "./status.mjs";
 import { withFileLock } from "./lock.mjs";
 
@@ -12,8 +17,6 @@ const GITHUB_API = "https://api.github.com";
 const COPILOT_TOKEN_URL = `${GITHUB_API}/copilot_internal/v2/token`;
 const DISABLE_TOKEN_DISCOVERY_VALUES = new Set(["1", "true", "yes"]);
 const MAX_AUTH_JSON_BYTES = 1024 * 1024;
-const DEFAULT_TOKEN_LOCK_TIMEOUT_MS = 10 * 60 * 1000;
-const DEFAULT_TOKEN_LOCK_STALE_MS = 15 * 60 * 1000;
 
 export function githubTokenPath(home = os.homedir()) {
   return path.join(home, ".local", "share", "copilot-api", "github_token");
@@ -58,15 +61,10 @@ function isTokenDiscoveryDisabled(env = process.env) {
   return DISABLE_TOKEN_DISCOVERY_VALUES.has(String(env.CCDX_DISABLE_TOKEN_DISCOVERY || "").toLowerCase());
 }
 
-function positiveInt(value, fallback) {
-  const n = Number.parseInt(value, 10);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
-
 function tokenLockOptions(env = process.env) {
   return {
-    timeoutMs: positiveInt(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, DEFAULT_TOKEN_LOCK_TIMEOUT_MS),
-    staleMs: positiveInt(env.CCDX_TOKEN_LOCK_STALE_MS, DEFAULT_TOKEN_LOCK_STALE_MS),
+    timeoutMs: parsePositiveInteger(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, RUNTIME_DEFAULTS.tokenLockTimeoutMs),
+    staleMs: parsePositiveInteger(env.CCDX_TOKEN_LOCK_STALE_MS, RUNTIME_DEFAULTS.tokenLockStaleMs),
   };
 }
 
@@ -215,22 +213,10 @@ function readSavedGithubToken(home = os.homedir()) {
   return fs.readFileSync(filePath, "utf8").trim();
 }
 
-function normalizeGithubIdentity(identity) {
-  if (!identity || typeof identity !== "object") return null;
-  const login = typeof identity.login === "string" ? identity.login.trim() : "";
-  const id = identity.id === undefined || identity.id === null ? "" : String(identity.id).trim();
-  if (!login && !id) return null;
-  return { login, id };
-}
-
-function tokenFingerprint(token) {
-  return createHash("sha256").update(String(token || "")).digest("hex").slice(0, 24);
-}
-
 export function readGithubTokenMetadata(home = os.homedir(), token = null) {
   try {
     const parsed = JSON.parse(fs.readFileSync(githubTokenMetadataPath(home), "utf8"));
-    if (token && parsed.token_fingerprint !== tokenFingerprint(token)) return null;
+    if (token && parsed.token_fingerprint !== githubTokenFingerprint(token)) return null;
     const identity = normalizeGithubIdentity(parsed);
     return identity ? { ...identity, token_fingerprint: parsed.token_fingerprint || "" } : null;
   } catch {
@@ -238,15 +224,6 @@ export function readGithubTokenMetadata(home = os.homedir(), token = null) {
   }
 }
 
-function githubIdentityMatches(identity, expected) {
-  const actual = normalizeGithubIdentity(identity);
-  const wanted = normalizeGithubIdentity(expected);
-  if (!wanted) return true;
-  if (!actual) return false;
-  if (wanted.id && actual.id) return wanted.id === actual.id;
-  return Boolean(wanted.login && actual.login && wanted.login.toLowerCase() === actual.login.toLowerCase());
-}
-
 function expectedGithubIdentity(home, env, token) {
   const configuredLogin = String(env.CCDX_GITHUB_LOGIN || "").trim();
   if (configuredLogin) return { login: configuredLogin };
@@ -374,7 +351,7 @@ export async function discoverGithubToken({
       const candidate = { ok: true, token, source, validation };
       const explicitSource = source.type === "env" || source.type === "token-file";
       if (expectedIdentity && (strictExpectedIdentity || !explicitSource)) {
-        if (githubIdentityMatches(validation, expectedIdentity)) return candidate;
+        if (githubIdentityMatchesExpected(validation, expectedIdentity)) return candidate;
         failures.push({ source, validation, reason: "github_account_mismatch" });
         continue;
       }
@@ -427,7 +404,7 @@ export async function importDiscoveredGithubToken({
         return { ok: true, token: savedToken, source: { type: "saved-token" }, imported: false };
       }
       const validation = await validateGithubToken(savedToken, { fetchImpl, signal });
-      if (validation.ok && githubIdentityMatches(validation, expectedIdentity)) {
+      if (validation.ok && githubIdentityMatchesExpected(validation, expectedIdentity)) {
         writeGithubTokenMetadata(validation, home, savedToken);
         return { ok: true, token: savedToken, source: { type: "saved-token" }, validation, imported: false };
       }
@@ -561,7 +538,7 @@ export function writeGithubTokenMetadata(identity, home = os.homedir(), token =
   fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
   fs.writeFileSync(filePath, `${JSON.stringify({
     ...normalized,
-    token_fingerprint: tokenFingerprint(token),
+    token_fingerprint: githubTokenFingerprint(token),
     updated_at: new Date().toISOString(),
   }, null, 2)}\n`, { mode: 0o600 });
   fs.chmodSync(filePath, 0o600);

package/src/copilot.mjs

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import os from "node:os";
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { status } from "./status.mjs";
 import { debugLog } from "./log.mjs";
 import {
@@ -11,6 +11,12 @@ import {
   readGithubTokenMetadata,
   writeGithubTokenMetadata,
 } from "./auth.mjs";
+import {
+  githubIdentitiesEqual,
+  githubIdentityLabel,
+  githubTokenFingerprint,
+  normalizeGithubIdentity,
+} from "./github-identity.mjs";
 import { prepareResponsesPayload } from "./image-optimization.mjs";
 
 export {
@@ -292,6 +298,21 @@ let copilotTokenGithubIdentity = null;
 let copilotTokenRefreshRetryAt = 0;
 const modelListFlights = new Map();
 
+export function copilotRuntimeStatus(now = Date.now()) {
+  let upstreamHost = "unknown";
+  try { upstreamHost = new URL(apiBase).hostname; } catch {}
+  return {
+    token_cached: Boolean(copilotToken),
+    token_expires_in_ms: copilotToken ? Math.max(0, copilotTokenExpiry - now) : null,
+    token_refresh_in_flight: Boolean(copilotTokenRefresh),
+    token_refresh_backoff_ms: Math.max(0, copilotTokenRefreshRetryAt - now),
+    account_bound: Boolean(copilotTokenGithubIdentity),
+    upstream_host: upstreamHost,
+    model_endpoint_cache_entries: modelEndpointCache.size,
+    model_list_flights: modelListFlights.size,
+  };
+}
+
 function getGithubToken({ home = os.homedir() } = {}) {
   const GITHUB_TOKEN_PATH = githubTokenPath(home);
   if (!fs.existsSync(GITHUB_TOKEN_PATH)) {
@@ -309,30 +330,6 @@ function requestCopilotToken(ghToken, { fetchImpl = fetch, signal } = {}) {
   });
 }
 
-function githubTokenFingerprint(token) {
-  return createHash("sha256").update(String(token || "")).digest("hex").slice(0, 24);
-}
-
-function normalizeGithubIdentity(identity) {
-  if (!identity || typeof identity !== "object") return null;
-  const login = typeof identity.login === "string" ? identity.login.trim() : "";
-  const id = identity.id === undefined || identity.id === null ? "" : String(identity.id).trim();
-  return login || id ? { login, id } : null;
-}
-
-function githubIdentitiesMatch(first, second) {
-  const a = normalizeGithubIdentity(first);
-  const b = normalizeGithubIdentity(second);
-  if (!a || !b) return false;
-  if (a.id && b.id) return a.id === b.id;
-  return Boolean(a.login && b.login && a.login.toLowerCase() === b.login.toLowerCase());
-}
-
-function githubIdentityLabel(identity) {
-  const normalized = normalizeGithubIdentity(identity);
-  return normalized?.login || normalized?.id || "unknown";
-}
-
 function cacheCopilotTokenData(data, {
   sourceKey,
   githubToken,
@@ -344,7 +341,7 @@ function cacheCopilotTokenData(data, {
   const identity = normalizeGithubIdentity(githubIdentity);
   const tokenChanged = Boolean(copilotTokenGithubFingerprint && fingerprint !== copilotTokenGithubFingerprint);
   if (!allowAccountSwitch && copilotTokenGithubIdentity && identity
-    && !githubIdentitiesMatch(copilotTokenGithubIdentity, identity)) {
+    && !githubIdentitiesEqual(copilotTokenGithubIdentity, identity)) {
     throw new Error(`Refusing to switch GitHub Copilot account from ${githubIdentityLabel(copilotTokenGithubIdentity)} to ${githubIdentityLabel(identity)} while the adapter is running. Restart codex-copilot-dx to switch accounts intentionally.`);
   }
   if (!allowAccountSwitch && copilotTokenGithubIdentity && tokenChanged && !identity) {

package/src/github-identity.mjs

@@ -0,0 +1,30 @@
+import { createHash } from "node:crypto";
+
+export function normalizeGithubIdentity(identity) {
+  if (!identity || typeof identity !== "object") return null;
+  const login = typeof identity.login === "string" ? identity.login.trim() : "";
+  const id = identity.id === undefined || identity.id === null ? "" : String(identity.id).trim();
+  return login || id ? { login, id } : null;
+}
+
+export function githubTokenFingerprint(token) {
+  return createHash("sha256").update(String(token || "")).digest("hex").slice(0, 24);
+}
+
+export function githubIdentitiesEqual(first, second) {
+  const a = normalizeGithubIdentity(first);
+  const b = normalizeGithubIdentity(second);
+  if (!a || !b) return false;
+  if (a.id && b.id) return a.id === b.id;
+  return Boolean(a.login && b.login && a.login.toLowerCase() === b.login.toLowerCase());
+}
+
+export function githubIdentityMatchesExpected(identity, expected) {
+  if (!normalizeGithubIdentity(expected)) return true;
+  return githubIdentitiesEqual(identity, expected);
+}
+
+export function githubIdentityLabel(identity) {
+  const normalized = normalizeGithubIdentity(identity);
+  return normalized?.login || normalized?.id || "unknown";
+}

package/src/http-transport.mjs

@@ -1,28 +1,20 @@
 import { promisify } from "node:util";
 import * as zlib from "node:zlib";
+import { loadRuntimeConfig, parsePositiveInteger } from "./runtime-config.mjs";
 import { status } from "./status.mjs";
 
-const DEFAULT_MAX_BODY_BYTES = 64 * 1024 * 1024;
-const DEFAULT_MAX_DECODED_BODY_BYTES = 128 * 1024 * 1024;
-const DEFAULT_MAX_INFLIGHT_BODY_BYTES = 32 * 1024 * 1024;
-const DEFAULT_MAX_QUEUED_REQUESTS = 16;
-const DEFAULT_REQUEST_QUEUE_TIMEOUT_MS = 120 * 1000;
 const COMPRESSED_BODY_WEIGHT_MULTIPLIER = 4;
 const gunzipAsync = promisify(zlib.gunzip);
 const inflateAsync = promisify(zlib.inflate);
 const brotliDecompressAsync = promisify(zlib.brotliDecompress);
 const zstdDecompressAsync = zlib.zstdDecompress ? promisify(zlib.zstdDecompress) : null;
 
-function positiveInt(value, fallback) {
-  const n = Number.parseInt(value, 10);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
-
-const MAX_BODY_BYTES = positiveInt(process.env.CCDX_MAX_BODY_BYTES, DEFAULT_MAX_BODY_BYTES);
-const MAX_DECODED_BODY_BYTES = positiveInt(process.env.CCDX_MAX_DECODED_BODY_BYTES, DEFAULT_MAX_DECODED_BODY_BYTES);
-const MAX_INFLIGHT_BODY_BYTES = positiveInt(process.env.CCDX_MAX_INFLIGHT_BODY_BYTES, DEFAULT_MAX_INFLIGHT_BODY_BYTES);
-const MAX_QUEUED_REQUESTS = positiveInt(process.env.CCDX_MAX_QUEUED_REQUESTS, DEFAULT_MAX_QUEUED_REQUESTS);
-const REQUEST_QUEUE_TIMEOUT_MS = positiveInt(process.env.CCDX_REQUEST_QUEUE_TIMEOUT_MS, DEFAULT_REQUEST_QUEUE_TIMEOUT_MS);
+const HTTP_RUNTIME_CONFIG = loadRuntimeConfig();
+const MAX_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxBodyBytes;
+const MAX_DECODED_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxDecodedBodyBytes;
+const MAX_INFLIGHT_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxInflightBodyBytes;
+const MAX_QUEUED_REQUESTS = HTTP_RUNTIME_CONFIG.maxQueuedRequests;
+const REQUEST_QUEUE_TIMEOUT_MS = HTTP_RUNTIME_CONFIG.requestQueueTimeoutMs;
 
 export function httpError(message, statusCode) {
   const err = new Error(message);
@@ -59,11 +51,22 @@ export function createRequestAdmission({
   maxQueued = MAX_QUEUED_REQUESTS,
   waitTimeoutMs = REQUEST_QUEUE_TIMEOUT_MS,
 } = {}) {
-  const byteLimit = positiveInt(maxBytes, MAX_INFLIGHT_BODY_BYTES);
-  const queueLimit = positiveInt(maxQueued, MAX_QUEUED_REQUESTS);
-  const timeoutMs = positiveInt(waitTimeoutMs, REQUEST_QUEUE_TIMEOUT_MS);
+  const byteLimit = parsePositiveInteger(maxBytes, MAX_INFLIGHT_BODY_BYTES);
+  const queueLimit = parsePositiveInteger(maxQueued, MAX_QUEUED_REQUESTS);
+  const timeoutMs = parsePositiveInteger(waitTimeoutMs, REQUEST_QUEUE_TIMEOUT_MS);
   const queue = [];
   let activeBytes = 0;
+  let activeRequests = 0;
+  const counters = {
+    total: 0,
+    activated: 0,
+    queued: 0,
+    rejected: 0,
+    timedOut: 0,
+    aborted: 0,
+    waitMsTotal: 0,
+    waitMsMax: 0,
+  };
 
   const remove = (entry) => {
     const index = queue.indexOf(entry);
@@ -73,11 +76,17 @@ export function createRequestAdmission({
   const activate = (entry) => {
     entry.cleanup();
     activeBytes += entry.weight;
+    activeRequests += 1;
+    counters.activated += 1;
+    const waitMs = Math.max(0, Date.now() - entry.startedAt);
+    counters.waitMsTotal += waitMs;
+    counters.waitMsMax = Math.max(counters.waitMsMax, waitMs);
     let released = false;
     entry.resolve(() => {
       if (released) return;
       released = true;
       activeBytes = Math.max(0, activeBytes - entry.weight);
+      activeRequests = Math.max(0, activeRequests - 1);
       drain();
     });
   };
@@ -99,16 +108,23 @@ export function createRequestAdmission({
   };
 
   const acquire = (req, { signal } = {}) => {
-    if (signal?.aborted) return Promise.reject(admissionAbortError(signal));
+    counters.total += 1;
+    if (signal?.aborted) {
+      counters.aborted += 1;
+      return Promise.reject(admissionAbortError(signal));
+    }
     const weight = requestAdmissionWeight(req, byteLimit);
     if (queue.length >= queueLimit && activeBytes + weight > byteLimit) {
+      counters.rejected += 1;
       return Promise.reject(httpError(`Request queue is full (${queueLimit} waiting)`, 503));
     }
+    if (activeBytes + weight > byteLimit) counters.queued += 1;
 
     return new Promise((resolve, reject) => {
       let timer;
       const entry = {
         cancelled: false,
+        startedAt: Date.now(),
         weight,
         resolve,
         cleanup: () => {
@@ -116,18 +132,20 @@ export function createRequestAdmission({
           signal?.removeEventListener("abort", onAbort);
         },
       };
-      const cancel = (error) => {
+      const cancel = (error, reason) => {
         if (entry.cancelled) return;
         entry.cancelled = true;
+        if (reason === "aborted") counters.aborted += 1;
+        if (reason === "timed_out") counters.timedOut += 1;
         entry.cleanup();
         remove(entry);
         reject(error);
         drain();
       };
-      const onAbort = () => cancel(admissionAbortError(signal));
+      const onAbort = () => cancel(admissionAbortError(signal), "aborted");
       signal?.addEventListener("abort", onAbort, { once: true });
       timer = setTimeout(() => {
-        cancel(httpError(`Request admission timed out after ${timeoutMs}ms`, 503));
+        cancel(httpError(`Request admission timed out after ${timeoutMs}ms`, 503), "timed_out");
       }, timeoutMs);
       timer.unref?.();
       queue.push(entry);
@@ -137,6 +155,24 @@ export function createRequestAdmission({
   };
 
   acquire.stats = () => ({ activeBytes, queued: queue.length, maxBytes: byteLimit });
+  acquire.diagnostics = () => ({
+    activeBytes,
+    activeRequests,
+    queued: queue.length,
+    maxBytes: byteLimit,
+    maxQueued: queueLimit,
+    waitTimeoutMs: timeoutMs,
+    total: counters.total,
+    activated: counters.activated,
+    queuedTotal: counters.queued,
+    rejected: counters.rejected,
+    timedOut: counters.timedOut,
+    aborted: counters.aborted,
+    waitMsAvg: counters.activated > 0
+      ? Number((counters.waitMsTotal / counters.activated).toFixed(1))
+      : 0,
+    waitMsMax: counters.waitMsMax,
+  });
   return acquire;
 }
 

package/src/image-optimization.mjs

@@ -61,7 +61,7 @@ export function createTaskLimiter(concurrency) {
     }
   };
 
-  return async function runLimited(task, { signal } = {}) {
+  const runLimited = async function runLimited(task, { signal } = {}) {
     if (signal?.aborted) throw abortError(signal);
     await new Promise((resolve, reject) => {
       const entry = {
@@ -91,10 +91,25 @@ export function createTaskLimiter(concurrency) {
       drain();
     }
   };
+  runLimited.stats = () => ({
+    active,
+    queued: queue.reduce((count, entry) => count + (entry.cancelled ? 0 : 1), 0),
+    limit,
+  });
+  return runLimited;
 }
 
 const runGlobalImageTask = createTaskLimiter(IMG_CONCURRENCY);
 
+export function imageOptimizationStats() {
+  return {
+    ...runGlobalImageTask.stats(),
+    disabled: IMG_OPT_DISABLED,
+    cache_entries: optimizedImageDigests.size,
+    sharp_loaded: sharpImport !== null,
+  };
+}
+
 async function sharp() {
   sharpImport ||= import("sharp");
   const mod = await sharpImport;