@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.210

package/src/server/prebuilt/synthetic-store.ts

@@ -0,0 +1,125 @@
+/**
+ * Synthetic ALS store for build-time capture (design/44 §Param Injection).
+ *
+ * Each param combo renders inside a `RequestContextStore` that provides
+ * segment params and NOTHING else. Every per-request API is a hard error,
+ * never a silent empty value — a component that branches on a header
+ * (locale, experiment, auth state) must fail the build, not bake the
+ * "header absent" branch into the cache for every future request:
+ *
+ * - `segmentParams.get()` works — reads from this store
+ * - `cookies()` / `headers()` / `searchParams` throw `BuildTimeContextError`
+ *
+ * The enforcement lives in the store's own fields (recording accessors)
+ * rather than in request-context.ts / cookie-context.ts, so the request
+ * path pays nothing and those modules stay untouched. The per-request
+ * fields — `headers`, `parsedCookies`, `searchParams` — are getters that
+ * record a violation and throw, so the CALL itself (`getHeaders()`,
+ * `getCookieJar()`, `getSearchParams()`) is the build error, not some
+ * later member read; merely obtaining and passing the object around is
+ * already outside the build-time contract (codex P2 round 5 on PR #836).
+ * `mutableContext` gets the same treatment because cookie MUTATORS reach
+ * it (via cookie-context's assertMutable, its only reader) before any
+ * other store field (codex P2 round 4).
+ *
+ * Every violation is recorded in a side channel BEFORE the throw — a
+ * component that catches the error (`try { headers() } catch { fallback }`)
+ * still fails its entry; accepting that render would silently bake the
+ * request-dependent fallback branch into the payload (codex P1 on PR #836).
+ * The capture pass checks the side channel after every render.
+ *
+ * This is safe precisely because capture renders the bare component
+ * element — no pipeline, no SSR bridge, no action machinery — so the only
+ * code that can reach these fields during a capture is the component
+ * itself (via the public accessors).
+ */
+
+import type { RequestContextStore } from '../als-registry.ts';
+import type { CoercedParams } from '../../shared/param-value.ts';
+
+/**
+ * Thrown when a prerendered component touches per-request context at
+ * build time. The capture pass treats this as a HARD build error —
+ * it indicates a design mistake, not transient bad data (design/44
+ * §Build-Phase Error Handling).
+ */
+export class BuildTimeContextError extends Error {
+  /** The per-request API that was called (e.g. "cookies()"). */
+  readonly api: string;
+
+  constructor(componentId: string, api: string) {
+    super(
+      `[timber] cache.component "${componentId}": ${api} cannot be used in a ` +
+        `prerendered component — there is no request at build time. Prerendered ` +
+        `components may read segment params and timber.cache data only. Remove the ` +
+        `${api} call, or drop { prerender: true } and render this component ` +
+        `per-request. (design/44-render-at-build-time.md §Param Injection)`
+    );
+    this.name = 'BuildTimeContextError';
+    this.api = api;
+  }
+}
+
+/** A synthetic store plus the side channel its accessors report into. */
+export interface BuildTimeStoreHandle {
+  store: RequestContextStore;
+  /**
+   * Every per-request API access during the render, recorded even when
+   * the accompanying throw was caught by user code. Non-empty after the
+   * render ⇒ the entry must fail as a hard build error.
+   */
+  violations: BuildTimeContextError[];
+  /** Whether the component read `segmentParams` during the render. */
+  segmentParamsRead: boolean;
+}
+
+/**
+ * Create the synthetic per-combo store. `segmentParams` must already be
+ * coerced through the route's codecs — cache-key parity with request time
+ * depends on hashing the exact record `coerceSegmentParams` produces.
+ */
+export function createBuildTimeStore(
+  componentId: string,
+  segmentParams: CoercedParams
+): BuildTimeStoreHandle {
+  const violations: BuildTimeContextError[] = [];
+  const handle: BuildTimeStoreHandle = {
+    store: null!,
+    violations,
+    segmentParamsRead: false,
+  };
+  const store: RequestContextStore = {
+    // No request at build time, so a stale-while-revalidate failure during
+    // capture is logged and not reported against a made-up one.
+    request: null,
+    headers: new Headers(),
+    originalHeaders: new Headers(),
+    cookieHeader: '',
+    searchParams: new URLSearchParams(),
+    searchString: '',
+    segmentParams,
+    cookieJar: new Map(),
+    flushed: false,
+    mutableContext: false,
+  };
+  const violate = (api: string): never => {
+    const error = new BuildTimeContextError(componentId, api);
+    violations.push(error);
+    throw error;
+  };
+  Object.defineProperties(store, {
+    headers: { get: () => violate('headers()') },
+    parsedCookies: { get: () => violate('cookies()') },
+    searchParams: { get: () => violate('searchParams') },
+    mutableContext: { get: () => violate('cookies()') },
+    segmentParams: {
+      get: () => {
+        handle.segmentParamsRead = true;
+        return segmentParams;
+      },
+      enumerable: true,
+    },
+  });
+  handle.store = store;
+  return handle;
+}

package/src/server/prebuilt-builder.ts

@@ -0,0 +1,514 @@
+/**
+ * Prebuilt payload capture — the post-build half of cache.component
+ * (TIM-1119, design/44-render-at-build-time.md §Build Phase).
+ *
+ * Runs AFTER Vite's 5-step build sequence, INSIDE the built RSC bundle:
+ * the component registry, the ALS instances, and the flight renderer are
+ * module instances in the bundle's graph, so the capture pass must share
+ * that graph — `server/rsc-entry/index.ts` re-exports this module's
+ * entry point as `__timber_capturePrebuilt`, and the timber-prebuilt
+ * plugin imports the built `rsc/index.js` and calls it.
+ *
+ * Per candidate route (a page with prebuilt components attributed by the
+ * build-time module-graph walk):
+ *
+ *   1. Load the page module (+ layout-chain modules that declare prebuilt
+ *      components) — module evaluation registers `__prebuilt` components.
+ *   2. Enumerate param combos: `generateStaticSegmentParams()` for dynamic
+ *      routes, the single empty combo for static routes.
+ *   3. Per combo, reconstruct the URL and run the REAL request-time pair —
+ *      `matchRoute` + `coerceSegmentParams` — so codec-coerced params hash
+ *      byte-identically to a live request. `computeComponentCacheKey` is
+ *      the single shared implementation (design/44 §Cache Key).
+ *   4. Render each registered component in isolation under a synthetic ALS
+ *      store (segment params only; cookies/headers/searchParams are hard
+ *      errors — synthetic-store.ts), fully drain the flight stream, and
+ *      smoke-revive the captured bytes once before accepting them.
+ *   5. Hand each payload to the caller's sink. Persistence (atomic file
+ *      writes, manifest.json) is the PLUGIN's job on the Node side —
+ *      keeping node:fs out of the server bundle, which must also run on
+ *      Cloudflare Workers.
+ *
+ * No payload source is registered while this runs, so wrappers rendered
+ * inside a captured subtree always miss and render live — inner output is
+ * baked flat into the outer entry, which is exactly the nesting clamp of
+ * design/45 §Nesting Semantics. The capture pass detects and reports the
+ * clamp (and fails cyclic entries) via capture-state.ts.
+ *
+ * Error policy (design/44 §Build-Phase Error Handling):
+ *   - `BuildTimeContextError` (cookies/headers/searchParams at build time)
+ *     → HARD error; the caller must fail the build.
+ *   - Anything else (bad data, deny(), cycles, timeouts, revival failures)
+ *     → skip that entry, warn, keep building.
+ */
+
+import type { CoercedParams } from '../shared/param-value.ts';
+import { ParamCoercionError } from './param-coercion.ts';
+import { coerceSegmentParams } from './param-coercion.ts';
+import { isDenySignal, isRedirectSignal } from './signal-identity.ts';
+import { computeComponentCacheKey } from './prebuilt/cache-key.ts';
+import { bytesToStream, renderEntry } from './prebuilt/capture-render.ts';
+import {
+  collectCandidateRoutes,
+  enumerateCombos,
+  type ParamCombo,
+} from './prebuilt/capture-routes.ts';
+import { warnNestingClamps } from './prebuilt/lifetime.ts';
+import { BuildTimeContextError } from './prebuilt/synthetic-store.ts';
+import { getPrebuiltRegistration } from './prebuilt-runtime.ts';
+import { createRouteMatcher } from './route-matcher.ts';
+import type { ManifestRoot } from './route-matcher.ts';
+import { createFromReadableStream } from '../rsc-runtime/rsc.ts';
+import { loadModule } from './safe-load.ts';
+import { resolvePathWithParams } from './sitemap-generator.ts';
+import { resolveRenderTimeoutMs } from './render-timeout.ts';
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+/** One captured flight payload, ready for the caller's persistence sink. */
+export interface CapturedEntry {
+  componentId: string;
+  /** `computeComponentCacheKey(callSiteProps, coercedParams)` — names the .flight file. */
+  cacheKey: string;
+  /** The param combo — manifest metadata, not the hash input. */
+  params: CoercedParams;
+  /** Call-site props used for this entry (empty object for zero-prop usages). */
+  props?: Record<string, unknown>;
+  bytes: Uint8Array;
+  /** Resolved tags from callsite options — static or function-form, evaluated at capture time. */
+  tags?: string[];
+  /** Component does not read segment params — cache key uses `{}`. */
+  paramIndependent?: boolean;
+}
+
+/** A per-entry problem — either a skip (build continues) or a hard error. */
+export interface CaptureIssue {
+  componentId: string;
+  routeUrlPath: string;
+  params: CoercedParams;
+  message: string;
+}
+
+export interface CaptureSummary {
+  /** Entries captured, smoke-revived, and accepted by the sink. */
+  captured: number;
+  /** Skipped entries — reported, build continues (design/44 policy). */
+  skipped: CaptureIssue[];
+  /** Dynamic-context violations — the caller MUST fail the build. */
+  hardErrors: CaptureIssue[];
+  /** Nesting-clamp warnings emitted (design/45 §Nesting Semantics). */
+  nestingWarnings: number;
+}
+
+export interface CaptureOptions {
+  /**
+   * Route file path (page or layout, absolute) → prebuilt component IDs
+   * transitively reachable from it. Computed by the timber-prebuilt
+   * plugin's RSC module-graph walk at generateBundle time.
+   */
+  fileComponentMap: Record<string, string[]>;
+  /**
+   * Component ID → array of distinct static call-site prop objects captured
+   * from JSX usage sites (design/44 §Props Derivation). Each entry renders
+   * one payload per (props, params) combination. Components with no captured
+   * props (zero-prop usages) render with `{}` — the pre-TIM-1142 behavior.
+   */
+  callSiteProps?: Record<string, Record<string, unknown>[]>;
+  /**
+   * Persistence sink, called once per accepted payload. Throws propagate
+   * and abort the capture — a failed artifact write is an infrastructure
+   * failure, not a per-entry data problem.
+   */
+  onEntry: (entry: CapturedEntry) => Promise<void>;
+  /**
+   * Component ID → built chunk file name (or URL) for declaring modules
+   * behind dynamic imports. The capture pass imports these to trigger
+   * cache.component() registration before rendering.
+   */
+  lazyChunks?: Record<string, string>;
+  /** @internal Override chunk loader for testing. */
+  _loadChunk?: (chunkFile: string) => Promise<void>;
+  /**
+   * Per-entry ceiling on render + drain. A component that hangs (stalled
+   * fetch, unbounded recursion the cycle guard can't see) fails its entry
+   * instead of hanging the whole build — the A2 stream-read rule from
+   * design/13-security.md applied to the build process.
+   */
+  renderTimeoutMs?: number;
+  /** Progress/warning logger. Defaults to console.warn. */
+  log?: (message: string) => void;
+}
+
+// ─── Lazy chunk loading ───────────────────────────────────────────────────
+
+/**
+ * Import a built chunk to trigger its cache.component() registrations.
+ * Resolves relative paths against this module's URL (works when bundled
+ * into rsc/index.js — chunks sit in sibling directories).
+ */
+async function loadLazyChunk(chunkFile: string): Promise<void> {
+  const url = /^[a-z]+:/i.test(chunkFile) ? chunkFile : new URL(chunkFile, import.meta.url).href;
+  await import(/* @vite-ignore */ url);
+}
+
+/** Human-readable classification for a failed entry. */
+function describeFailure(error: unknown): string {
+  if (isDenySignal(error)) return `component called deny(${error.status})`;
+  if (isRedirectSignal(error)) return `component called redirect("${error.location}")`;
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+// ─── Capture orchestration ────────────────────────────────────────────────
+
+/** Buffered entry pending the param-independence decision (TIM-1175). */
+interface PendingEntry {
+  callSiteProps: Record<string, unknown>;
+  cacheKey: string;
+  combo: ParamCombo;
+  bytes: Uint8Array;
+  tags: string[] | undefined;
+}
+
+function pendingToCapturedEntry(componentId: string, entry: PendingEntry): CapturedEntry {
+  const hasProps = Object.keys(entry.callSiteProps).length > 0;
+  return {
+    componentId,
+    cacheKey: entry.cacheKey,
+    params: entry.combo,
+    ...(hasProps ? { props: entry.callSiteProps } : {}),
+    bytes: entry.bytes,
+    tags: entry.tags,
+  };
+}
+
+/**
+ * Capture flight payloads for every attributed, registered, prerender-tier
+ * component across the route manifest. See module docblock for the flow.
+ */
+export async function capturePrebuiltPayloads(
+  manifest: ManifestRoot,
+  options: CaptureOptions
+): Promise<CaptureSummary> {
+  const log = options.log ?? ((message: string) => console.warn(message));
+  const timeoutMs = resolveRenderTimeoutMs(options.renderTimeoutMs);
+  const matchRoute = createRouteMatcher(manifest);
+
+  const summary: CaptureSummary = { captured: 0, skipped: [], hardErrors: [], nestingWarnings: 0 };
+  const seenEntries = new Set<string>();
+  const warnedPairs = new Set<string>();
+  const reportedMissingRegistrations = new Set<string>();
+  const eagerLoadedChunks = new Set<string>();
+  // Components already emitted as param-independent — skip on second route.
+  const emittedParamIndependent = new Set<string>();
+  // (componentId, propsKey) pairs that rendered at least once without
+  // reading segment params. Segment param access is structural (the
+  // component either calls getSegmentParams() or it doesn't), so if the
+  // first combo doesn't trigger it, subsequent combos won't either —
+  // skip them to avoid redundant renders. Tracked per props set so a
+  // failed variant doesn't suppress retries for a different variant.
+  const provenParamIndependent = new Set<string>();
+  // Per-component: whether ANY combo read segmentParams, plus buffered
+  // entries awaiting the param-independence decision after all combos.
+  const pendingByComponent = new Map<string, { anyParamRead: boolean; entries: PendingEntry[] }>();
+
+  const skip = (issue: CaptureIssue) => {
+    summary.skipped.push(issue);
+    log(
+      `[timber] cache.component skipped "${issue.componentId}" for ${issue.routeUrlPath} ` +
+        `${JSON.stringify(issue.params)} — ${issue.message}`
+    );
+  };
+
+  for (const route of collectCandidateRoutes(manifest.root, options.fileComponentMap)) {
+    // Load the page + prebuilt-declaring layout modules. Evaluation is what
+    // registers module-scope __prebuilt components (design/44 §Registration).
+    let pageModule: Record<string, unknown>;
+    try {
+      pageModule = await loadModule(route.page);
+      for (const layout of route.layoutsToLoad) await loadModule(layout);
+    } catch (error) {
+      for (const componentId of route.componentIds) {
+        skip({
+          componentId,
+          routeUrlPath: route.urlPath,
+          params: {},
+          message: describeFailure(error),
+        });
+      }
+      continue;
+    }
+
+    let combos: ParamCombo[] | null;
+    try {
+      combos = await enumerateCombos(route, pageModule, log);
+    } catch (error) {
+      for (const componentId of route.componentIds) {
+        skip({
+          componentId,
+          routeUrlPath: route.urlPath,
+          params: {},
+          message: describeFailure(error),
+        });
+      }
+      continue;
+    }
+    if (combos === null) continue;
+
+    for (const combo of combos) {
+      if (combo === null || typeof combo !== 'object' || Array.isArray(combo)) {
+        skip({
+          componentId: route.componentIds[0],
+          routeUrlPath: route.urlPath,
+          params: {},
+          message: `generateStaticSegmentParams returned a non-object combo: ${JSON.stringify(combo)}`,
+        });
+        continue;
+      }
+      // Reconstruct the URL and run the request-time matcher + coercion so
+      // the params record — and therefore the cache key — is byte-identical
+      // to what a live request for this combo produces.
+      const path = resolvePathWithParams(route.urlPath, combo);
+      if (path === null) {
+        skip({
+          componentId: route.componentIds[0],
+          routeUrlPath: route.urlPath,
+          params: combo,
+          message: 'param combo is missing a required dynamic segment value',
+        });
+        continue;
+      }
+      const match = matchRoute(path);
+      if (
+        !match ||
+        match.segments[match.segments.length - 1]?.page?.filePath !== route.page.filePath
+      ) {
+        skip({
+          componentId: route.componentIds[0],
+          routeUrlPath: route.urlPath,
+          params: combo,
+          message: `resolved URL "${path}" does not match this route (another route shadows it)`,
+        });
+        continue;
+      }
+      let coercedParams: CoercedParams;
+      try {
+        coercedParams = await coerceSegmentParams(match);
+      } catch (error) {
+        skip({
+          componentId: route.componentIds[0],
+          routeUrlPath: route.urlPath,
+          params: combo,
+          message:
+            error instanceof ParamCoercionError
+              ? `param coercion rejected the combo: ${error.message}`
+              : describeFailure(error),
+        });
+        continue;
+      }
+
+      for (const componentId of route.componentIds) {
+        let registration = getPrebuiltRegistration(componentId);
+        if (!registration) {
+          const chunkFile = options.lazyChunks?.[componentId];
+          if (chunkFile && !eagerLoadedChunks.has(chunkFile)) {
+            eagerLoadedChunks.add(chunkFile);
+            try {
+              await (options._loadChunk ?? loadLazyChunk)(chunkFile);
+            } catch {
+              // Fall through — skip below will report.
+            }
+            registration = getPrebuiltRegistration(componentId);
+          }
+          if (!registration) {
+            if (!reportedMissingRegistrations.has(componentId)) {
+              reportedMissingRegistrations.add(componentId);
+              skip({
+                componentId,
+                routeUrlPath: route.urlPath,
+                params: combo,
+                message:
+                  'attributed to this route but never registered at module load — the ' +
+                  'declaring module is probably loaded via dynamic import; it will render live',
+              });
+            }
+            continue;
+          }
+        }
+        // Runtime tier (ttl/tags without prerender) does no build work.
+        if (registration.options.prerender !== true) continue;
+        // Already emitted as param-independent from a prior route.
+        if (emittedParamIndependent.has(componentId)) continue;
+
+        // One entry per distinct call-site props object (design/44 §Props
+        // Derivation, TIM-1142). When no call-site props were captured,
+        // render with empty props (the pre-TIM-1142 behavior). When
+        // captured props exist, render ONLY those — a spurious {} render
+        // on a component that always receives props could hit a throw
+        // path (e.g., required prop access) and fail the build for a
+        // shape no JSX call site actually uses.
+        const capturedProps = options.callSiteProps?.[componentId];
+        const propsSets: Record<string, unknown>[] =
+          capturedProps && capturedProps.length > 0 ? [...capturedProps] : [{}];
+
+        let pending = pendingByComponent.get(componentId);
+        if (!pending) {
+          pending = { anyParamRead: false, entries: [] };
+          pendingByComponent.set(componentId, pending);
+        }
+
+        for (const callSiteProps of propsSets) {
+          // Already rendered this (component, props) pair without reading
+          // params — additional combos produce identical payloads. Tracked
+          // per props set so a failed variant doesn't suppress retries.
+          // Guard on !anyParamRead: if another prop variant already proved
+          // param-dependent, this variant needs per-combo entries too since
+          // the emit phase uses a component-level paramIndependent flag.
+          const propsKey = JSON.stringify(callSiteProps);
+          const proofKey = `${componentId}\0${propsKey}`;
+          if (provenParamIndependent.has(proofKey) && !pending.anyParamRead) continue;
+
+          const cacheKey = computeComponentCacheKey(callSiteProps, coercedParams);
+          if (cacheKey === null) {
+            skip({
+              componentId,
+              routeUrlPath: route.urlPath,
+              params: combo,
+              message:
+                'coerced segment params are unkeyable (see design/44 §Cache Key) — ' +
+                'requests will always render live',
+            });
+            continue;
+          }
+          const entryKey = `${componentId} ${cacheKey}`;
+          if (seenEntries.has(entryKey)) continue;
+          seenEntries.add(entryKey);
+
+          const isLayout = route.layoutComponentIds.has(componentId);
+          const outcome = await renderEntry(
+            registration,
+            callSiteProps,
+            coercedParams,
+            timeoutMs,
+            isLayout
+          );
+          // Track param reads immediately — before any failure continue —
+          // so a combo that reads params then fails still prevents
+          // param-independent classification (codex P1 on PR #869).
+          if (outcome.segmentParamsRead) {
+            const wasParamIndep = !pending.anyParamRead;
+            pending.anyParamRead = true;
+            provenParamIndependent.delete(proofKey);
+            // Flush buffered entries immediately — they're confirmed
+            // param-dependent and don't need to wait for the emit phase.
+            // Avoids retaining all combo payloads in memory (TIM-1179).
+            if (wasParamIndep) {
+              for (const buffered of pending.entries) {
+                await options.onEntry(pendingToCapturedEntry(componentId, buffered));
+                summary.captured++;
+              }
+              pending.entries = [];
+            }
+          } else if (outcome.failure === null && !pending.anyParamRead) {
+            provenParamIndependent.add(proofKey);
+          }
+          if (outcome.failure !== null) {
+            const issue: CaptureIssue = {
+              componentId,
+              routeUrlPath: route.urlPath,
+              params: combo,
+              message: describeFailure(outcome.failure),
+            };
+            if (outcome.failure instanceof BuildTimeContextError) {
+              summary.hardErrors.push(issue);
+              log(`[timber] BUILD ERROR: ${issue.message}`);
+            } else {
+              skip(issue);
+            }
+            continue;
+          }
+
+          // Write-time integrity: revive the captured bytes once, exactly the
+          // way the request path will, before accepting them. Corrupt or
+          // truncated captures fail HERE, at build time — the request path
+          // trusts artifacts the way it trusts JS chunks in the same deploy.
+          try {
+            await createFromReadableStream(bytesToStream(outcome.bytes!));
+          } catch (error) {
+            skip({
+              componentId,
+              routeUrlPath: route.urlPath,
+              params: combo,
+              message: `captured payload failed smoke revival: ${describeFailure(error)}`,
+            });
+            continue;
+          }
+
+          // Clamp warnings for an accepted entry only: a skipped one stores
+          // nothing to clamp (and a failed render never resolved its tags),
+          // and must not spend the pair's one warning.
+          summary.nestingWarnings += warnNestingClamps(
+            {
+              id: componentId,
+              options: registration.options,
+              tags: outcome.resolvedTags ?? [],
+            },
+            outcome.nested,
+            warnedPairs,
+            log
+          );
+
+          // Once param-dependent is confirmed, emit directly instead of
+          // buffering — no need to hold bytes in memory (TIM-1179).
+          if (pending.anyParamRead) {
+            await options.onEntry(
+              pendingToCapturedEntry(componentId, {
+                callSiteProps,
+                cacheKey,
+                combo,
+                bytes: outcome.bytes!,
+                tags: outcome.resolvedTags,
+              })
+            );
+            summary.captured++;
+          } else {
+            pending.entries.push({
+              callSiteProps,
+              cacheKey,
+              combo,
+              bytes: outcome.bytes!,
+              tags: outcome.resolvedTags,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // Emit remaining buffered entries — only param-independent components
+  // still have entries here (param-dependent entries were emitted eagerly
+  // above, TIM-1179). Collapse to one entry per props set (TIM-1175).
+  for (const [componentId, pending] of pendingByComponent) {
+    if (pending.entries.length === 0) continue;
+    emittedParamIndependent.add(componentId);
+    const emittedProps = new Set<string>();
+    for (const entry of pending.entries) {
+      const propsKey = JSON.stringify(entry.callSiteProps);
+      if (emittedProps.has(propsKey)) continue;
+      emittedProps.add(propsKey);
+      const hasProps = Object.keys(entry.callSiteProps).length > 0;
+      await options.onEntry({
+        componentId,
+        cacheKey: computeComponentCacheKey(entry.callSiteProps, {}) ?? entry.cacheKey,
+        params: {},
+        ...(hasProps ? { props: entry.callSiteProps } : {}),
+        bytes: entry.bytes,
+        tags: entry.tags,
+        paramIndependent: true,
+      });
+      summary.captured++;
+    }
+  }
+
+  return summary;
+}