@decocms/blocks 7.15.0 → 7.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks",
-  "version": "7.15.0",
+  "version": "7.16.0",
   "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));

package/src/sdk/otel.ts

@@ -99,6 +99,23 @@ import { RequestContext } from "./requestContext";
 // ---------------------------------------------------------------------------
 
 export interface OtelOptions {
+  /**
+   * When `true`, skips all observability exporters (AE, OTLP metrics,
+   * logs, traces). Overridden by the env var.
+   */
+  disabled?: boolean;
+  /**
+   * Env var name holding the tri-state observability switch. Values:
+   * - `"on"`   → force enable (even in local dev)
+   * - `"off"`  → force disable
+   * - unset    → auto: enabled in real deploys, disabled in local
+   *
+   * Local is detected by the absence of `CF_VERSION_METADATA` (a binding
+   * that only exists in production/preview Cloudflare deploys).
+   *
+   * Defaults to `"DECO_OTEL"`.
+   */
+  envVar?: string;
   /** Logical service name. Falls back to `env.DECO_SITE_NAME`, then "deco-site". */
   serviceName?: string;
   /** Env var name holding the AE binding. Defaults to `"DECO_METRICS"`. */
@@ -624,6 +641,18 @@ function bootObservability(opts: OtelOptions, env: Record<string, unknown>): voi
   const state = getBootState();
   if (state.booted) return;
 
+  // CF_VERSION_METADATA is only present in real (production/preview) deploys;
+  // wrangler dev never sets it, making it a reliable local-dev signal.
+  const mode = env[opts.envVar ?? "DECO_OTEL"];
+  const isLocal = !env.CF_VERSION_METADATA;
+  const isDisabled =
+    mode === "off" ||
+    (mode !== "on" && (opts.disabled || isLocal));
+  if (isDisabled) {
+    state.booted = true;
+    return;
+  }
+
   // Capture the original console.warn BEFORE patchConsole() runs. The onError
   // callbacks below need a direct channel to console that bypasses the logger
   // to avoid routing exporter-level warnings back through the OTLP adapter