chainlesschain 0.165.6 → 0.165.8

package/src/lib/gitlab-mr-worktree.js

@@ -0,0 +1,176 @@
+/**
+ * Local-only GitLab merge-request reference parsing and worktree footer UI.
+ *
+ * This intentionally performs no network I/O and never accepts a token. A
+ * caller may render an MR produced by a later `glab`/GitLab integration while
+ * preserving a safe, portable contract for local worktree workflows.
+ */
+
+const MAX_REFERENCE_BYTES = 4096;
+const MAX_TITLE_BYTES = 512;
+const SEGMENT_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/u;
+const IID_RE = /^[1-9][0-9]{0,9}$/u;
+
+function safeText(value, label, maximum) {
+  if (
+    typeof value !== "string" ||
+    !value ||
+    Buffer.byteLength(value, "utf8") > maximum ||
+    /[\r\n\u0000-\u001f\u007f]/u.test(value)
+  ) {
+    throw new TypeError(`${label} is invalid`);
+  }
+  return value;
+}
+
+function safeProjectPath(value) {
+  const segments = String(value || "").split("/");
+  if (
+    segments.length < 2 ||
+    segments.some((segment) => !SEGMENT_RE.test(segment))
+  ) {
+    throw new TypeError("GitLab project path is invalid");
+  }
+  return segments.join("/");
+}
+
+function safeHost(value) {
+  const host = safeText(String(value || "").toLowerCase(), "GitLab host", 255);
+  if (
+    !/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/u.test(host) &&
+    host !== "localhost"
+  ) {
+    throw new TypeError("GitLab host is invalid");
+  }
+  return host;
+}
+
+function safeIid(value) {
+  const iid = String(value || "");
+  if (!IID_RE.test(iid)) throw new TypeError("GitLab MR iid is invalid");
+  return Number(iid);
+}
+
+function buildWebUrl(host, projectPath, iid) {
+  return `https://${host}/${projectPath}/-/merge_requests/${iid}`;
+}
+
+/**
+ * Parse an HTTPS GitLab web URL or `namespace/project!iid` shorthand. Nested
+ * subgroup paths are allowed; credentials, query strings and fragments are
+ * rejected rather than echoed into terminal output.
+ */
+export function parseGitLabMergeRequestReference(value, options = {}) {
+  const input = safeText(
+    String(value || "").trim(),
+    "GitLab MR reference",
+    MAX_REFERENCE_BYTES,
+  );
+  if (/(?:^|\/)(?:\.|\.\.)(?:\/|$)/u.test(input)) {
+    throw new TypeError("GitLab MR reference is invalid");
+  }
+  const shorthand = input.match(/^(.+)!([1-9][0-9]{0,9})$/u);
+  if (shorthand && !input.includes("://")) {
+    const host = safeHost(options.defaultHost || "gitlab.com");
+    const projectPath = safeProjectPath(shorthand[1]);
+    const iid = safeIid(shorthand[2]);
+    return Object.freeze({
+      host,
+      projectPath,
+      iid,
+      webUrl: buildWebUrl(host, projectPath, iid),
+    });
+  }
+
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new TypeError("GitLab MR reference is invalid");
+  }
+  if (
+    url.protocol !== "https:" ||
+    url.username ||
+    url.password ||
+    url.port ||
+    url.search ||
+    url.hash
+  ) {
+    throw new TypeError("GitLab MR reference is invalid");
+  }
+  const parts = url.pathname.split("/").filter(Boolean);
+  const marker = parts.lastIndexOf("-");
+  if (
+    marker < 2 ||
+    parts[marker + 1] !== "merge_requests" ||
+    parts.length !== marker + 3
+  ) {
+    throw new TypeError("GitLab MR reference is invalid");
+  }
+  const host = safeHost(url.hostname);
+  const projectPath = safeProjectPath(parts.slice(0, marker).join("/"));
+  const iid = safeIid(parts[marker + 2]);
+  return Object.freeze({
+    host,
+    projectPath,
+    iid,
+    webUrl: buildWebUrl(host, projectPath, iid),
+  });
+}
+
+function safeOptionalText(value, label, maximum = 255) {
+  if (value == null || value === "") return null;
+  return safeText(String(value), label, maximum);
+}
+
+/** Normalize a local GitLab MR display model without retaining API extras. */
+export function normalizeGitLabMergeRequest(value, options = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError("GitLab MR is invalid");
+  }
+  const reference = parseGitLabMergeRequestReference(
+    value.webUrl || value.web_url || value.reference,
+    options,
+  );
+  const iid = value.iid == null ? reference.iid : safeIid(value.iid);
+  if (iid !== reference.iid)
+    throw new TypeError("GitLab MR iid does not match reference");
+  const state = safeOptionalText(
+    value.state || "opened",
+    "GitLab MR state",
+    32,
+  )?.toLowerCase();
+  if (state && !new Set(["opened", "closed", "merged", "locked"]).has(state)) {
+    throw new TypeError("GitLab MR state is invalid");
+  }
+  return Object.freeze({
+    ...reference,
+    title: safeOptionalText(value.title, "GitLab MR title", MAX_TITLE_BYTES),
+    state: state || "opened",
+    sourceBranch: safeOptionalText(
+      value.sourceBranch || value.source_branch,
+      "GitLab MR source branch",
+    ),
+    targetBranch: safeOptionalText(
+      value.targetBranch || value.target_branch,
+      "GitLab MR target branch",
+    ),
+  });
+}
+
+/** Render a compact, safe footer suitable for terminal and IDE worktree views. */
+export function renderGitLabMergeRequestFooter(value, options = {}) {
+  const mr = normalizeGitLabMergeRequest(value, options);
+  const lines = [`GitLab MR !${mr.iid} · ${mr.state}`, mr.webUrl];
+  if (mr.title) lines.push(mr.title);
+  if (mr.sourceBranch || mr.targetBranch) {
+    lines.push(`${mr.sourceBranch || "?"} → ${mr.targetBranch || "?"}`);
+  }
+  const worktreePath = safeOptionalText(
+    options.worktreePath,
+    "GitLab worktree path",
+    4096,
+  );
+  if (worktreePath) lines.push(`worktree: ${worktreePath}`);
+  return lines.join("\n");
+}

package/src/lib/hooks-v2-producers.js

@@ -1,21 +1,94 @@
 /**
  * Best-effort bridge from real runtime producers to Hooks v2.
  * Hook failures never change the surrounding agent or interaction result.
+ *
+ * A headless host may subscribe to a particular session to project a small,
+ * machine-readable lifecycle stream.  The projection deliberately excludes
+ * hook command lines, input, output, and error text: hooks often handle
+ * credentials, paths, and user content.  The observer is diagnostic only and
+ * is never allowed to affect a hook decision.
  */
-export function emitHooksV2Event(eventName, context = {}, options = {}) {
-  void executeHooksV2Event(eventName, context, options);
+const sessionObservers = new Map();
+
+function safeId(value, max = 160) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, max) : null;
 }
 
-/**
- * Decision-capable producer bridge. Callers at a real gate (PreToolUse,
- * Setup, prompt expansion) await this result; observer producers can keep
- * using emitHooksV2Event().
- */
-export async function executeHooksV2Event(
-  eventName,
-  context = {},
-  options = {},
-) {
+function observerSetFor(context = {}) {
+  const sessionId = safeId(context.session_id ?? context.sessionId);
+  return sessionId ? sessionObservers.get(sessionId) || null : null;
+}
+
+function projectLifecycle(eventName, context = {}, phase, outcome = null) {
+  const projected = {
+    type: phase,
+    schema_version: 1,
+    hook_event: safeId(eventName, 96) || "unknown",
+  };
+  const sessionId = safeId(context.session_id ?? context.sessionId);
+  const traceId = safeId(context.trace_id ?? context.traceId);
+  const parentId = safeId(context.parent_id ?? context.parentId);
+  const turnId = safeId(context.turn_id ?? context.turnId);
+  const toolUseId = safeId(context.tool_use_id ?? context.toolUseId);
+  if (sessionId) projected.session_id = sessionId;
+  if (traceId) projected.trace_id = traceId;
+  if (parentId) projected.parent_id = parentId;
+  if (turnId) projected.turn_id = turnId;
+  if (toolUseId) projected.tool_use_id = toolUseId;
+  if (!outcome || typeof outcome !== "object") return projected;
+
+  if (phase === "hook_progress") {
+    projected.hook_id = safeId(outcome.hookId, 160) || null;
+    projected.status = safeId(outcome.status, 32) || "unknown";
+    projected.decision = safeId(outcome.decision, 32) || "continue";
+    if (Number.isFinite(outcome.durationMs)) {
+      projected.duration_ms = Math.max(0, Math.floor(outcome.durationMs));
+    }
+    return projected;
+  }
+
+  projected.decision = safeId(outcome.decision, 32) || "continue";
+  projected.blocked = outcome.blocked === true;
+  projected.requires_approval = outcome.requiresApproval === true;
+  projected.hook_count = Array.isArray(outcome.results)
+    ? outcome.results.length
+    : 0;
+  projected.error = outcome.error ? "hook_runtime_error" : undefined;
+  return projected;
+}
+
+function notifyObservers(eventName, context, phase, outcome = null) {
+  const observers = observerSetFor(context);
+  if (!observers || observers.size === 0) return;
+  const event = projectLifecycle(eventName, context, phase, outcome);
+  for (const observer of observers) {
+    try {
+      observer(event);
+    } catch {
+      // Observability must never delay or weaken the hook boundary.
+    }
+  }
+}
+
+/** Register a diagnostic observer for a single canonical session id. */
+export function addHooksV2EventObserver(sessionId, observer) {
+  const key = safeId(sessionId);
+  if (!key || typeof observer !== "function") return () => {};
+  let observers = sessionObservers.get(key);
+  if (!observers) {
+    observers = new Set();
+    sessionObservers.set(key, observers);
+  }
+  observers.add(observer);
+  return () => {
+    observers.delete(observer);
+    if (observers.size === 0) sessionObservers.delete(key);
+  };
+}
+
+async function dispatchHooksV2Event(eventName, context, options) {
   try {
     const { default: runtime } = await import("./hooks-v2-runtime.js");
     if (!runtime || typeof runtime.executeHooks !== "function") {
@@ -39,6 +112,39 @@ export async function executeHooksV2Event(
   }
 }
 
+function reportOutcome(eventName, context, outcome) {
+  for (const result of Array.isArray(outcome?.results) ? outcome.results : []) {
+    notifyObservers(eventName, context, "hook_progress", result);
+  }
+  notifyObservers(eventName, context, "hook_response", outcome);
+  return outcome;
+}
+
+export function emitHooksV2Event(eventName, context = {}, options = {}) {
+  notifyObservers(eventName, context, "hook_started");
+  void dispatchHooksV2Event(eventName, context, options).then((outcome) =>
+    reportOutcome(eventName, context, outcome),
+  );
+}
+
+/**
+ * Decision-capable producer bridge. Callers at a real gate (PreToolUse,
+ * Setup, prompt expansion) await this result; observer producers can keep
+ * using emitHooksV2Event().
+ */
+export async function executeHooksV2Event(
+  eventName,
+  context = {},
+  options = {},
+) {
+  notifyObservers(eventName, context, "hook_started");
+  return reportOutcome(
+    eventName,
+    context,
+    await dispatchHooksV2Event(eventName, context, options),
+  );
+}
+
 export function resolvePromptExpansion(prompt, outcome = {}) {
   const base = String(prompt ?? "");
   const updates = [];
@@ -69,8 +175,6 @@ export function resolvePromptExpansion(prompt, outcome = {}) {
     prompt: resolved,
     blocked: outcome.blocked === true || outcome.decision === "block",
     reason:
-      outcome.blockingResult?.reason ||
-      outcome.blockingResult?.message ||
-      null,
+      outcome.blockingResult?.reason || outcome.blockingResult?.message || null,
   };
 }

package/src/lib/hooks-v2-workspace-context.js

@@ -2,6 +2,10 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import {
+  evaluateWorkspaceTrustDecision,
+  projectWorkspaceTrustAudit,
+} from "./workspace-trust.js";
 
 const trustedWorkspaceStorage = new AsyncLocalStorage();
 const registeredHostWorkspaces = new Map();
@@ -57,12 +61,37 @@ function captureWorkspaceIdentity(workspaceRoot) {
       "Hooks v2 host workspace root must resolve to a directory",
     );
   }
-  return Object.freeze({
+  const identity = {
     canonicalRoot,
     device: stats.dev,
     inode: stats.ino,
     generation: workspaceGeneration(stats),
+  };
+  // Hooks have no user-configured path authority: the trusted host bootstrap
+  // is their separate evidence/consent channel.  It still passes through the
+  // shared canonical identity and strict lattice so audit consumers see the
+  // same repository/worktree identity as MCP and plugins.
+  const decision = evaluateWorkspaceTrustDecision({
+    workspaceRoot: canonicalRoot,
+    evidence: [
+      {
+        source: "hooks",
+        consent: "host-bound",
+        fingerprint: `${stats.dev}\0${stats.ino}\0${identity.generation}`,
+        decision: "allow",
+      },
+    ],
   });
+  if (decision.decision !== "allow") {
+    throw invalidWorkspaceRoot(
+      "Hooks v2 host workspace trust identity is unavailable",
+    );
+  }
+  Object.defineProperty(identity, "workspaceTrustAudit", {
+    value: projectWorkspaceTrustAudit(decision),
+    enumerable: false,
+  });
+  return Object.freeze(identity);
 }
 
 function workspaceIdentityKey(identity) {
@@ -242,6 +271,20 @@ export function resolveHostHooksV2WorkspaceBinding(binding) {
   return verifyWorkspaceRecord(record);
 }
 
+/**
+ * Return the redacted shared trust projection for one currently valid Hooks
+ * binding.  It deliberately exposes neither the canonical path nor a host
+ * identity token.
+ */
+export function projectHostHooksV2WorkspaceTrustAudit(binding) {
+  if (!binding || typeof binding !== "object") return null;
+  const record = registeredHostWorkspaces.get(binding.bindingId);
+  if (!record || record.binding !== binding || !verifyWorkspaceRecord(record)) {
+    return null;
+  }
+  return record.identity.workspaceTrustAudit || null;
+}
+
 /**
  * Resolve an opaque durable binding only against roots registered by the
  * current host process. No persisted or event-supplied path is accepted.

package/src/lib/host-resource-budget.js

@@ -0,0 +1,295 @@
+/**
+ * Host-owned, content-free resource accounting for long-running agent hosts.
+ *
+ * This is intentionally separate from a provider/session budget: it applies
+ * backpressure to host queues and caches before work is admitted, while an
+ * optional SessionResourceBudget remains the shared authority for tool time.
+ * Queue slots retain only opaque identifiers, never renderer/event payloads.
+ */
+
+import { randomUUID } from "node:crypto";
+
+export const HOST_BACKLOG_KINDS = Object.freeze(["renderer", "tool", "event"]);
+
+export const DEFAULT_HOST_RESOURCE_LIMITS = Object.freeze({
+  webFetchTtlMs: 60_000,
+  maxWebFetchEntries: 32,
+  maxWebFetchBytes: 8 * 1024 * 1024,
+  maxWebSearchResults: 20,
+  maxRendererBacklog: 64,
+  maxToolBacklog: 32,
+  maxEventBacklog: 256,
+});
+
+const BACKLOG_LIMIT_FIELDS = Object.freeze({
+  renderer: "maxRendererBacklog",
+  tool: "maxToolBacklog",
+  event: "maxEventBacklog",
+});
+
+function normalizeNonNegativeInteger(field, value) {
+  const normalized = Number(value);
+  if (!Number.isSafeInteger(normalized) || normalized < 0) {
+    throw new TypeError(`invalid host resource budget limit: ${field}`);
+  }
+  return normalized;
+}
+
+function normalizePositiveInteger(field, value) {
+  const normalized = normalizeNonNegativeInteger(field, value);
+  if (normalized < 1) {
+    throw new TypeError(`invalid host resource budget limit: ${field}`);
+  }
+  return normalized;
+}
+
+function cloneCacheValue(value) {
+  // WebFetch produces JSON-compatible values. structuredClone retains arrays
+  // and JSON output without allowing callers to mutate the retained cache.
+  if (typeof structuredClone === "function") return structuredClone(value);
+  return JSON.parse(JSON.stringify(value));
+}
+
+function cacheValueBytes(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+export class HostResourceBudgetError extends Error {
+  constructor(reason, message = null) {
+    super(message || `Host resource budget exhausted: ${reason}`);
+    this.name = "HostResourceBudgetError";
+    this.code = "ERR_HOST_RESOURCE_BUDGET";
+    this.budgetReason = reason;
+    this.retryable = false;
+  }
+}
+
+/**
+ * A host creates one instance per interactive/headless run and passes it to
+ * tool adapters. Slots represent work waiting to be rendered, completed, or
+ * delivered; callers must release them once their consumer has drained it.
+ */
+export class HostResourceBudget {
+  constructor({
+    sessionBudget = null,
+    webFetchTtlMs = DEFAULT_HOST_RESOURCE_LIMITS.webFetchTtlMs,
+    maxWebFetchEntries = DEFAULT_HOST_RESOURCE_LIMITS.maxWebFetchEntries,
+    maxWebFetchBytes = DEFAULT_HOST_RESOURCE_LIMITS.maxWebFetchBytes,
+    maxWebSearchResults = DEFAULT_HOST_RESOURCE_LIMITS.maxWebSearchResults,
+    maxRendererBacklog = DEFAULT_HOST_RESOURCE_LIMITS.maxRendererBacklog,
+    maxToolBacklog = DEFAULT_HOST_RESOURCE_LIMITS.maxToolBacklog,
+    maxEventBacklog = DEFAULT_HOST_RESOURCE_LIMITS.maxEventBacklog,
+    now = () => Date.now(),
+  } = {}) {
+    if (
+      sessionBudget !== null &&
+      (typeof sessionBudget !== "object" ||
+        typeof sessionBudget.beginTool !== "function")
+    ) {
+      throw new TypeError("sessionBudget must provide beginTool()");
+    }
+    if (typeof now !== "function") {
+      throw new TypeError("host resource budget now must be a function");
+    }
+
+    this._sessionBudget = sessionBudget;
+    this._now = now;
+    this.webFetchTtlMs = normalizeNonNegativeInteger(
+      "webFetchTtlMs",
+      webFetchTtlMs,
+    );
+    this.maxWebFetchEntries = normalizeNonNegativeInteger(
+      "maxWebFetchEntries",
+      maxWebFetchEntries,
+    );
+    this.maxWebFetchBytes = normalizeNonNegativeInteger(
+      "maxWebFetchBytes",
+      maxWebFetchBytes,
+    );
+    this.maxWebSearchResults = normalizePositiveInteger(
+      "maxWebSearchResults",
+      maxWebSearchResults,
+    );
+    this._backlogs = new Map(
+      HOST_BACKLOG_KINDS.map((kind) => [
+        kind,
+        {
+          max: normalizeNonNegativeInteger(
+            BACKLOG_LIMIT_FIELDS[kind],
+            {
+              maxRendererBacklog,
+              maxToolBacklog,
+              maxEventBacklog,
+            }[BACKLOG_LIMIT_FIELDS[kind]],
+          ),
+          slots: new Set(),
+        },
+      ]),
+    );
+    this._webFetchCache = new Map();
+    this._webFetchCacheBytes = 0;
+  }
+
+  _backlog(kind) {
+    const backlog = this._backlogs.get(kind);
+    if (!backlog) throw new TypeError(`invalid host backlog kind: ${kind}`);
+    return backlog;
+  }
+
+  admit(kind) {
+    const backlog = this._backlog(kind);
+    if (backlog.slots.size >= backlog.max) {
+      throw new HostResourceBudgetError(`${kind}-backlog`);
+    }
+    const id = `host-${kind}-${randomUUID()}`;
+    backlog.slots.add(id);
+    let released = false;
+    return Object.freeze({
+      id,
+      kind,
+      release: () => {
+        if (released) return false;
+        released = true;
+        return backlog.slots.delete(id);
+      },
+    });
+  }
+
+  admitRenderer() {
+    return this.admit("renderer");
+  }
+
+  admitEvent() {
+    return this.admit("event");
+  }
+
+  admitTool({ kind = "tool" } = {}) {
+    const slot = this.admit("tool");
+    let sessionLease = null;
+    try {
+      if (this._sessionBudget) {
+        const admission = this._sessionBudget.beginTool({
+          id: `host-tool-${randomUUID()}`,
+          kind: String(kind || "tool"),
+        });
+        if (!admission?.ok) {
+          throw new HostResourceBudgetError(
+            `session-${admission?.reason || "tool-admission"}`,
+          );
+        }
+        sessionLease = admission;
+      }
+    } catch (error) {
+      slot.release();
+      throw error;
+    }
+
+    let released = false;
+    return Object.freeze({
+      ...slot,
+      release: () => {
+        if (released) return false;
+        released = true;
+        try {
+          sessionLease?.end();
+        } catch {
+          // A session may already be aborting when a completed host I/O task
+          // releases its slot. The authoritative abort is preserved, while
+          // this cleanup must still make the bounded host slot reusable.
+        } finally {
+          slot.release();
+        }
+        return true;
+      },
+    });
+  }
+
+  capWebSearchResults(value) {
+    const requested = normalizePositiveInteger("webSearchResults", value);
+    return Math.min(requested, this.maxWebSearchResults);
+  }
+
+  _expireWebFetch(now = this._now()) {
+    for (const [key, entry] of this._webFetchCache) {
+      if (entry.expiresAt > now) continue;
+      this._webFetchCache.delete(key);
+      this._webFetchCacheBytes -= entry.bytes;
+    }
+  }
+
+  getWebFetch(key) {
+    if (typeof key !== "string" || key.length === 0) return null;
+    this._expireWebFetch();
+    const entry = this._webFetchCache.get(key);
+    if (!entry) return null;
+    // Map insertion order gives us a bounded LRU cache without retaining any
+    // user-provided key outside the configured entry/byte ceilings.
+    this._webFetchCache.delete(key);
+    this._webFetchCache.set(key, entry);
+    return cloneCacheValue(entry.value);
+  }
+
+  putWebFetch(key, value) {
+    if (
+      this.webFetchTtlMs === 0 ||
+      this.maxWebFetchEntries === 0 ||
+      this.maxWebFetchBytes === 0 ||
+      typeof key !== "string" ||
+      key.length === 0
+    ) {
+      return false;
+    }
+    const copy = cloneCacheValue(value);
+    const bytes = cacheValueBytes(copy);
+    if (bytes > this.maxWebFetchBytes) return false;
+    this._expireWebFetch();
+    const previous = this._webFetchCache.get(key);
+    if (previous) {
+      this._webFetchCache.delete(key);
+      this._webFetchCacheBytes -= previous.bytes;
+    }
+    while (
+      this._webFetchCache.size >= this.maxWebFetchEntries ||
+      this._webFetchCacheBytes + bytes > this.maxWebFetchBytes
+    ) {
+      const oldest = this._webFetchCache.entries().next().value;
+      if (!oldest) break;
+      const [oldestKey, oldestEntry] = oldest;
+      this._webFetchCache.delete(oldestKey);
+      this._webFetchCacheBytes -= oldestEntry.bytes;
+    }
+    this._webFetchCache.set(key, {
+      expiresAt: this._now() + this.webFetchTtlMs,
+      bytes,
+      value: copy,
+    });
+    this._webFetchCacheBytes += bytes;
+    return true;
+  }
+
+  status() {
+    this._expireWebFetch();
+    const backlog = Object.fromEntries(
+      [...this._backlogs.entries()].map(([kind, state]) => [
+        kind,
+        { active: state.slots.size, max: state.max },
+      ]),
+    );
+    return Object.freeze({
+      limits: Object.freeze({
+        webFetchTtlMs: this.webFetchTtlMs,
+        maxWebFetchEntries: this.maxWebFetchEntries,
+        maxWebFetchBytes: this.maxWebFetchBytes,
+        maxWebSearchResults: this.maxWebSearchResults,
+        maxRendererBacklog: backlog.renderer.max,
+        maxToolBacklog: backlog.tool.max,
+        maxEventBacklog: backlog.event.max,
+      }),
+      backlog: Object.freeze(backlog),
+      webFetchCache: Object.freeze({
+        entries: this._webFetchCache.size,
+        bytes: this._webFetchCacheBytes,
+      }),
+    });
+  }
+}