@decocms/blocks 7.15.0 → 7.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks",
-  "version": "7.15.0",
+  "version": "7.15.1",
   "type": "module",
   "engines": {
     "node": ">=24"

package/src/cms/layoutCacheRace.test.ts

@@ -1,8 +1,10 @@
 import { describe, expect, it } from "vitest";
 import {
   registerLayoutSections,
+  registerSectionLoader,
   registerSections,
   resolveDecoPage,
+  runSectionLoaders,
   setBlocks,
   unregisterLayoutSections,
 } from "./index";
@@ -103,6 +105,39 @@ describe("resolveDecoPage — layout section cache does not leak `.index` across
     }
   });
 
+  it("does not leak index across sequential requests when the result is already in the TTL cache", async () => {
+    // This covers the scenario missing from the concurrent test above:
+    // Page A is fully served first (result lands in layoutCache), then Page B
+    // arrives and hits the cache — it must get its own index, not Page A's.
+    const FOOTER_KEY = "site/sections/SeqCacheFooter.tsx";
+
+    registerLayoutSections([FOOTER_KEY]);
+    registerSectionLoader(FOOTER_KEY, async (props) => props);
+
+    const req = new Request("https://example.com/");
+    const makeSection = (index: number) => ({
+      component: FOOTER_KEY,
+      props: {},
+      key: `${FOOTER_KEY}-${index}`,
+      index,
+    });
+
+    try {
+      // First request: populate the TTL cache with index 2.
+      const [sectionA] = await runSectionLoaders([makeSection(2)], req);
+
+      // Second request: hits the TTL cache — must get index 7, not 2.
+      const [sectionB] = await runSectionLoaders([makeSection(7)], req);
+
+      expect(sectionA?.index).toBe(2);
+      expect(sectionB?.index).toBe(7);
+      // Must be separate objects — the cached entry must never carry an index.
+      expect(sectionA).not.toBe(sectionB);
+    } finally {
+      unregisterLayoutSections([FOOTER_KEY]);
+    }
+  });
+
   it("mechanism check: mutating a shared object in place under concurrent stamping loses one side's index (isolated, framework-independent)", async () => {
     // This isolates the exact bug mechanism from the diff that shipped in
     // 6.12.1 and was reverted after the rollback, independent of the CMS

package/src/cms/sectionLoaders.ts

@@ -270,19 +270,26 @@ function resolveLayoutSection(
   request: Request,
 ): Promise<ResolvedSection> {
   const key = section.component;
+  const { index } = section;
+
+  // Re-apply the caller's page-specific index onto a fresh object so the
+  // shared cache entry never carries an index from a previous request.
+  const withIndex = (s: ResolvedSection): ResolvedSection =>
+    index !== undefined ? { ...s, index } : s;
 
   const cached = getCachedLayout(key);
-  if (cached) return Promise.resolve(cached);
+  if (cached) return Promise.resolve(withIndex(cached));
 
   const existing = layoutInflight.get(key);
-  if (existing) return existing;
+  if (existing) return existing.then(withIndex);
 
   const promise = withInflightTimeout(
     (async () => {
       const enrichedProps = await loader(section.props as Record<string, unknown>, request);
-      const enriched = { ...section, props: enrichedProps };
+      const { index: _idx, ...sectionWithoutIndex } = section;
+      const enriched = { ...sectionWithoutIndex, props: enrichedProps };
       setCachedLayout(key, enriched);
-      return enriched;
+      return withIndex(enriched);
     })(),
     `layoutSection ${key}`,
   ).finally(() => layoutInflight.delete(key));