jamdesk 1.1.49 → 1.1.51

package/vendored/lib/layout-helpers.tsx

@@ -0,0 +1,470 @@
+// Shared chrome rendered by the docs catch-all layout. Inputs (config,
+// language, project slug) are resolved upstream from middleware headers
+// or — in non-ISR dev/tests — from URL params; this module owns the
+// rendering once those have resolved.
+import { Inter, JetBrains_Mono } from 'next/font/google';
+import { preload, preinit } from 'react-dom';
+import fs from 'fs';
+import path from 'path';
+import { ThemeProvider } from '@/components/theme/ThemeProvider';
+import { LayoutWrapper } from '@/components/layout/LayoutWrapper';
+import { CodeBlockCopyButton } from '@/components/CodeBlockCopyButton';
+import { HeaderLinkCopy } from '@/components/HeaderLinkCopy';
+import { FontAwesomeLoader } from '@/components/FontAwesomeLoader';
+import { JdReadySentinel } from '@/components/JdReadySentinel';
+import { HtmlLangSync } from '@/components/HtmlLangSync';
+import { FA_CSS_HREF } from '@/lib/font-awesome';
+import { getTheme, type ThemeName } from '@/themes';
+import {
+  generateFontImports,
+  generateFontVariables,
+  isPreloadedFont,
+  getPrimaryFontFamily,
+} from '@/lib/fonts';
+import type { DocsConfig, FontConfig, LanguageCode } from '@/lib/docs-types';
+import { LinkPrefixProvider } from '@/lib/link-prefix-context';
+import { ProjectSlugProvider } from '@/lib/project-slug-context';
+import { getAnalyticsScript } from '@/lib/analytics-script';
+
+// Pre-load fonts at module scope — Next.js requires this for static analysis.
+export const inter = Inter({
+  subsets: ['latin'],
+  display: 'swap',
+  variable: '--font-primary',
+});
+
+export const jetbrainsMono = JetBrains_Mono({
+  subsets: ['latin'],
+  display: 'swap',
+  variable: '--font-mono',
+});
+
+export function getLocalFileContent(filename: string): string | null {
+  try {
+    const filePath = path.join(process.cwd(), 'public', filename);
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, 'utf8');
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null;
+}
+
+export function getThemeCssContent(themeName: ThemeName | undefined): string | null {
+  try {
+    const theme = getTheme(themeName);
+    const themeCssPath = path.join(process.cwd(), 'themes', theme.cssPath);
+    if (fs.existsSync(themeCssPath)) {
+      return fs.readFileSync(themeCssPath, 'utf8');
+    }
+  } catch {
+    // Ignore errors - will use default styles from globals.css
+  }
+  return null;
+}
+
+export function generatePrimaryColorVariables(
+  primaryColor?: string,
+  lightColor?: string,
+  darkColor?: string,
+): string | null {
+  if (!primaryColor) return null;
+
+  // Validate that the color is a valid hex, rgb, or hsl value to prevent XSS
+  const colorRegex = /^(#[0-9a-f]{3}|#[0-9a-f]{6}|rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)|hsl\(\s*\d+\s*,\s*\d+%\s*,\s*\d+%\s*\))$/i;
+
+  if (!colorRegex.test(primaryColor.trim())) {
+    console.warn(`Invalid color value: ${primaryColor}. Color must be a valid hex, rgb, or hsl value.`);
+    return null;
+  }
+
+  const validLight = lightColor && colorRegex.test(lightColor.trim()) ? lightColor.trim() : null;
+  const validDark = darkColor && colorRegex.test(darkColor.trim()) ? darkColor.trim() : null;
+
+  // Light mode uses primary color, dark mode uses light color (or primary if light not provided)
+  const darkModeColor = validLight || primaryColor.trim();
+
+  return `:root {
+  --color-primary: ${primaryColor.trim()};
+  --color-primary-dark: ${validDark || primaryColor.trim()};
+  --color-accent: ${primaryColor.trim()};
+  --color-accent-hover: ${validDark || primaryColor.trim()};
+  --color-accent-text: color-mix(in srgb, ${primaryColor.trim()} 85%, black);
+}
+
+.dark {
+  --color-primary: ${darkModeColor};
+  --color-primary-dark: ${primaryColor.trim()};
+  --color-accent: ${darkModeColor};
+  --color-accent-hover: ${validLight || darkModeColor};
+  --color-accent-text: color-mix(in srgb, ${darkModeColor} 85%, white);
+}`;
+}
+
+export function getFontClassName(
+  themeName: ThemeName | undefined,
+  customFonts?: FontConfig,
+): string {
+  const primaryFont = getPrimaryFontFamily(customFonts);
+
+  if (primaryFont) {
+    const classes: string[] = [];
+
+    if (isPreloadedFont(primaryFont)) {
+      if (primaryFont === 'Inter') {
+        classes.push(inter.variable, inter.className);
+      } else if (primaryFont === 'JetBrains Mono') {
+        classes.push(jetbrainsMono.variable, 'font-mono');
+      } else {
+        classes.push(inter.variable, inter.className);
+      }
+    } else {
+      classes.push('font-sans');
+    }
+
+    classes.push(jetbrainsMono.variable);
+    return classes.join(' ');
+  }
+
+  const theme = getTheme(themeName);
+  if (theme.name === 'nebula') {
+    return `${jetbrainsMono.variable} font-mono`;
+  }
+  return `${inter.variable} ${jetbrainsMono.variable} ${inter.className}`;
+}
+
+async function ConditionalGTM({ gtmId }: { gtmId: string }) {
+  try {
+    const { GoogleTagManager } = await import('@next/third-parties/google');
+    return <GoogleTagManager gtmId={gtmId} />;
+  } catch (error) {
+    console.error('Failed to load GoogleTagManager:', error);
+    return null;
+  }
+}
+
+async function ConditionalGA({ gaId }: { gaId: string }) {
+  try {
+    const { GoogleAnalytics } = await import('@next/third-parties/google');
+    return <GoogleAnalytics gaId={gaId} />;
+  } catch (error) {
+    console.error('Failed to load GoogleAnalytics:', error);
+    return null;
+  }
+}
+
+function PlausibleScript({
+  domain,
+  server,
+  scriptUrl,
+}: {
+  domain?: string;
+  server?: string;
+  scriptUrl?: string;
+}): React.ReactElement {
+  // Paid proxy script mode (pa-XXXXX.js) — Plausible's CDN handles routing internally
+  if (scriptUrl) {
+    return (
+      <>
+        <script async src={scriptUrl} />
+        <script dangerouslySetInnerHTML={{
+          __html: 'window.plausible=window.plausible||function(){(plausible.q=plausible.q||[]).push(arguments)},plausible.init=plausible.init||function(i){plausible.o=i||{}};plausible.init()',
+        }} />
+      </>
+    );
+  }
+
+  const baseServer = server || 'https://plausible.io';
+  const plausibleServer = baseServer.replace(/\/+$/, '');
+  const scriptProps: Record<string, unknown> = {
+    defer: true,
+    'data-domain': domain,
+    src: `${plausibleServer}/js/script.js`,
+  };
+  if (server) {
+    scriptProps['data-api'] = `${plausibleServer}/api/event`;
+  }
+  return <script {...scriptProps} />;
+}
+
+interface DocsChromeProps {
+  config: DocsConfig;
+  resolvedProjectSlug: string;
+  lang: LanguageCode;
+  dir: 'rtl' | undefined;
+  projectDefaultLang: LanguageCode;
+  customCss: string | null;
+  customJs: string | null;
+  children: React.ReactNode;
+}
+
+/**
+ * Full docs chrome — html shell, head tags, providers, scripts. Rendered
+ * by the docs catch-all layout (`app/[[...slug]]/layout.tsx`) once it has
+ * resolved its inputs (config, language, project slug, custom CSS/JS).
+ */
+export async function DocsChrome({
+  config,
+  resolvedProjectSlug,
+  lang,
+  dir,
+  projectDefaultLang,
+  customCss,
+  customJs,
+  children,
+}: DocsChromeProps): Promise<React.ReactElement> {
+  const themeName = config.theme as ThemeName | undefined;
+  const themeCss = themeName && themeName !== 'jam' ? getThemeCssContent(themeName) : null;
+  const fontClassName = getFontClassName(themeName, config.fonts);
+
+  const fontImports = generateFontImports(config.fonts);
+  const fontVariables = generateFontVariables(config.fonts);
+
+  const primaryColorVariables = generatePrimaryColorVariables(
+    config.colors?.primary,
+    config.colors?.light,
+    config.colors?.dark,
+  );
+
+  const appearanceDefault = config.appearance?.default || 'system';
+  const appearanceStrict = config.appearance?.strict || false;
+
+  const linkPrefix = config.hostAtDocs ? '/docs' : '';
+
+  const analyticsScript = config.analytics?.enabled !== false
+    ? getAnalyticsScript(resolvedProjectSlug)
+    : null;
+
+  // Font Awesome CSS uses preinit (not preload) so React 19 emits the
+  // stylesheet link in <head> at SSR time. The previous approach used a
+  // beforeInteractive Script that injected <link rel=stylesheet> at runtime —
+  // that delayed @font-face parsing past the preloaded fonts' "few seconds"
+  // grace window, producing the chrome console warning "preloaded but not
+  // used within a few seconds." preinit closes the gap: the preloaded fonts
+  // are matched to their @font-face declarations as soon as the stylesheet
+  // parses, which now starts at HTML-parse time alongside the preloads.
+  //
+  // The font preloads stay on react-dom preload() so React 19 dedupes them
+  // (JSX <link rel=preload> tags used to ship twice — once from the JSX tree,
+  // once from React's preload manager). The <noscript> fallback below uses
+  // dangerouslySetInnerHTML for the same reason: a JSX <link rel=stylesheet>
+  // inside noscript was being hoisted into <head> as a real stylesheet.
+  preinit(FA_CSS_HREF, { as: 'style' });
+  preload('/_jd/fonts/fontawesome/webfonts/fa-light-300.woff2', { as: 'font', type: 'font/woff2', crossOrigin: 'anonymous' });
+  preload('/_jd/fonts/fontawesome/webfonts/fa-brands-400.woff2', { as: 'font', type: 'font/woff2', crossOrigin: 'anonymous' });
+
+  return (
+    <html lang={lang} dir={dir} suppressHydrationWarning data-scroll-behavior="smooth">
+      <head>
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        {config.fonts && (
+          <>
+            <link rel="preconnect" href="https://fonts.googleapis.com" />
+            <link rel="preconnect" href="https://fonts.gstatic.com" crossOrigin="anonymous" />
+          </>
+        )}
+        {/* Font Awesome stylesheet is emitted by the preinit() call above —
+            React 19 hoists it to <head> at SSR time. The <noscript> fallback
+            below uses dangerouslySetInnerHTML so React doesn't hoist *that*
+            <link rel="stylesheet"> into <head> as a real stylesheet. */}
+        <noscript dangerouslySetInnerHTML={{ __html: `<link rel="stylesheet" href="${FA_CSS_HREF}">` }} />
+        {config.styling?.latex && (
+          <link rel="dns-prefetch" href="https://cdn.jsdelivr.net" />
+        )}
+        {config.styling?.latex && (
+          <link
+            rel="stylesheet"
+            href="https://cdn.jsdelivr.net/npm/katex@0.16.10/dist/katex.min.css"
+            crossOrigin="anonymous"
+          />
+        )}
+        {(config.integrations?.ga4 || config.integrations?.gtm) && (
+          <link rel="dns-prefetch" href="https://www.googletagmanager.com" />
+        )}
+        {config.integrations?.posthog && (
+          <link rel="dns-prefetch" href={config.integrations.posthog.apiHost || "https://app.posthog.com"} />
+        )}
+        {process.env.NODE_ENV === 'production' && (config.integrations?.plausible?.domain || config.integrations?.plausible?.scriptUrl) && (
+          <link rel="dns-prefetch" href={(() => {
+            try {
+              return config.integrations!.plausible!.scriptUrl
+                ? new URL(config.integrations!.plausible!.scriptUrl).origin
+                : config.integrations!.plausible!.server || "https://plausible.io";
+            } catch {
+              return config.integrations!.plausible!.server || "https://plausible.io";
+            }
+          })()} />
+        )}
+        {config.integrations?.crisp && (
+          <link rel="dns-prefetch" href="https://client.crisp.chat" />
+        )}
+        {config.integrations?.intercom && (
+          <link rel="dns-prefetch" href="https://widget.intercom.io" />
+        )}
+        {config.integrations?.hotjar && (
+          <link rel="dns-prefetch" href="https://static.hotjar.com" />
+        )}
+        {config.integrations?.segment && (
+          <link rel="dns-prefetch" href="https://cdn.segment.com" />
+        )}
+        {/*
+          Project-subdomain hydration-error + dev-overlay suppression.
+          Gated to production so the inline <script> doesn't trigger React
+          19's "scripts inside React components are never executed when
+          rendering on the client" warning in `jamdesk dev`. The IIFE
+          itself already self-gates to non-localhost subdomains, so dev
+          was a no-op — gating the JSX is pure dev-console cleanup.
+        */}
+        {process.env.NODE_ENV === 'production' && (
+        <script
+          dangerouslySetInnerHTML={{
+            __html: `
+(function() {
+  var h = location.hostname;
+  var isSubdomain = h.split('.').length > 2 && h.indexOf('localhost') === -1 && h.indexOf('vercel.app') === -1;
+  if (!isSubdomain) return;
+
+  window.__IS_PROJECT_SITE__ = true;
+
+  window.addEventListener('error', function(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    console.log('[Project] Suppressed error:', e.message);
+    return true;
+  }, true);
+
+  window.addEventListener('unhandledrejection', function(e) {
+    e.preventDefault();
+    console.log('[Project] Suppressed rejection:', e.reason);
+    return true;
+  }, true);
+
+  var origError = console.error;
+  console.error = function() {
+    var msg = arguments[0];
+    if (typeof msg === 'string' && (
+      msg.indexOf('Hydration') !== -1 ||
+      msg.indexOf('hydrat') !== -1 ||
+      msg.indexOf('did not match') !== -1 ||
+      msg.indexOf('server-rendered') !== -1
+    )) {
+      console.log('[Project] Suppressed hydration warning');
+      return;
+    }
+    origError.apply(console, arguments);
+  };
+
+  var style = document.createElement('style');
+  style.textContent = 'nextjs-portal, [data-next-badge], [data-next-badge-root], next-badge-root, [data-nextjs-dialog-root] { display: none !important; visibility: hidden !important; }';
+  document.head.appendChild(style);
+
+  var removeDevIndicators = function() {
+    document.querySelectorAll('next-badge-root, [data-next-badge-root], nextjs-portal').forEach(function(el) {
+      el.remove();
+    });
+  };
+  removeDevIndicators();
+  var observeBody = function() {
+    if (document.body) {
+      new MutationObserver(removeDevIndicators).observe(document.body, { childList: true, subtree: true });
+    }
+  };
+  if (document.body) { observeBody(); } else { document.addEventListener('DOMContentLoaded', observeBody, { once: true }); }
+})();
+            `,
+          }}
+        />
+        )}
+        {/*
+          precedence + stable href lets React 19 hoist these into <head> as
+          managed resources and dedupe across renders, so theme/font styles
+          aren't recreated on each soft navigation.
+        */}
+        {fontImports && (
+          <style
+            precedence="jd-layout"
+            href={`jd-fonts-${resolvedProjectSlug}`}
+          >
+            {fontImports}
+          </style>
+        )}
+        {fontVariables && (
+          <style
+            precedence="jd-layout"
+            href={`jd-font-vars-${resolvedProjectSlug}`}
+          >
+            {fontVariables}
+          </style>
+        )}
+        {themeCss && (
+          <style precedence="jd-layout" href={`jd-theme-${themeName ?? 'jam'}`}>
+            {themeCss}
+          </style>
+        )}
+        {primaryColorVariables && (
+          <style
+            precedence="jd-layout"
+            href={`jd-colors-${resolvedProjectSlug}`}
+          >
+            {primaryColorVariables}
+          </style>
+        )}
+        {customCss && (
+          <style
+            precedence="jd-layout"
+            href={`jd-custom-${resolvedProjectSlug}`}
+          >
+            {customCss}
+          </style>
+        )}
+        {process.env.NODE_ENV === 'production' && (config.integrations?.plausible?.domain || config.integrations?.plausible?.scriptUrl) && (
+          <PlausibleScript
+            domain={config.integrations.plausible.domain}
+            server={config.integrations.plausible.server}
+            scriptUrl={config.integrations.plausible.scriptUrl}
+          />
+        )}
+      </head>
+      <body className={fontClassName} data-theme={themeName || 'jam'}>
+        {config.integrations?.gtm?.tagId && (
+          <ConditionalGTM gtmId={config.integrations.gtm.tagId} />
+        )}
+        <ThemeProvider
+          defaultTheme={appearanceDefault}
+          forcedTheme={appearanceStrict ? (appearanceDefault === 'system' ? undefined : appearanceDefault as 'light' | 'dark') : undefined}
+        >
+          <LinkPrefixProvider prefix={linkPrefix}>
+            <ProjectSlugProvider slug={resolvedProjectSlug || ''}>
+              <LayoutWrapper config={config}>
+                {children}
+              </LayoutWrapper>
+            </ProjectSlugProvider>
+          </LinkPrefixProvider>
+          <CodeBlockCopyButton />
+          <HeaderLinkCopy />
+          <FontAwesomeLoader />
+          <HtmlLangSync defaultLanguage={projectDefaultLang} />
+        </ThemeProvider>
+        {config.integrations?.crisp?.websiteId &&
+          /^[a-f0-9-]{36}$/.test(config.integrations.crisp.websiteId) && (
+          <script
+            dangerouslySetInnerHTML={{
+              __html: `window.$crisp=[];window.CRISP_WEBSITE_ID="${config.integrations.crisp.websiteId}";(function(){var d=document;var s=d.createElement("script");s.src="https://client.crisp.chat/l.js";s.async=1;d.getElementsByTagName("head")[0].appendChild(s)})();`,
+            }}
+          />
+        )}
+        {customJs && (
+          <script dangerouslySetInnerHTML={{ __html: customJs }} />
+        )}
+        {analyticsScript && (
+          <script dangerouslySetInnerHTML={{ __html: analyticsScript }} />
+        )}
+        {config.integrations?.ga4?.measurementId && (
+          <ConditionalGA gaId={config.integrations.ga4.measurementId} />
+        )}
+        <JdReadySentinel />
+      </body>
+    </html>
+  );
+}

package/vendored/lib/middleware-helpers.ts

@@ -27,89 +27,11 @@ import type { NextRequest } from 'next/server';
  */
 export const VALID_SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
 
-/**
- * Mangle a request pathname so it routes into the (docs)/[project] sub-tree.
- * The proxy applies this rewrite internally; user-visible URLs are unchanged.
- *
- * Slug must be URL-safe — VALID_SLUG_RE catches that upstream, so we
- * fail loud here if something slipped through.
- */
-export function injectProjectSlugIntoPath(
-  pathname: string,
-  projectSlug: string,
-  _hostAtDocs: boolean,
-): string {
-  if (!pathname || !pathname.startsWith('/')) {
-    throw new Error(`injectProjectSlugIntoPath: invalid pathname '${pathname}'`);
-  }
-  if (!VALID_SLUG_RE.test(projectSlug)) {
-    throw new Error(`injectProjectSlugIntoPath: invalid slug '${projectSlug}'`);
-  }
-  // hostAtDocs note: the user URL has /docs prefix; we still inject [project]
-  // BEFORE everything else so the route is /[project]/docs/<rest>. The
-  // existing (docs)/[project]/[[...slug]] catch-all handles either shape.
-  if (pathname === '/') return `/${projectSlug}/`;
-  return `/${projectSlug}${pathname}`;
-}
-
-/**
- * Names of static endpoint route handlers that live at the bare app/<name>/route.ts
- * (and their app/docs/<name>/route.ts twins for hostAtDocs sites). They render
- * project-aware output, but do so by reading x-project-slug headers — they are
- * NOT inside the (docs)/[project] sub-tree, so rewriting their URL to inject a
- * /[project]/ prefix would route to a path that doesn't exist and 404.
- *
- * KEEP IN SYNC with the actual files on disk: every app/<name>/route.ts must
- * appear here. The Step 5 verification grep guards against drift.
- */
-export const STATIC_ENDPOINT_NAMES = [
-  'sitemap.xml',
-  'llms.txt',
-  'llms-full.txt',
-  'robots.txt',
-  'feed.xml',
-  'docs.json',
-  'search-data.json',
-] as const;
-
-/** Precomputed path set so the hot-path check avoids per-call template allocs. */
-const STATIC_ENDPOINT_PATHS = new Set<string>(
-  STATIC_ENDPOINT_NAMES.flatMap((n) => [`/${n}`, `/docs/${n}`]),
-);
-
-/** Roots that bypass the (docs) rewrite — both `/X` exact and `/X/...` prefix. */
-const SYSTEM_PATH_ROOTS = [
-  '/_next',      // Next.js asset traffic — most-common bypass for docs sites
-  '/api',
-  '/_jd',
-  '/.well-known',
-  '/jd/unlock',
-] as const;
-
 /** True if pathname is exactly `root` or lives under `root/`. */
 export function isPathOrUnder(pathname: string, root: string): boolean {
   return pathname === root || pathname.startsWith(root + '/');
 }
 
-/**
- * Return true when a pathname should be internally rewritten into the
- * (docs)/[project] route group. Stays outside the group for:
- *   - SYSTEM_PATH_ROOTS            (api routes, Next assets, _jd, .well-known, unlock)
- *   - STATIC_ENDPOINT_NAMES files  (sitemap.xml, llms.txt, robots.txt, feed.xml,
- *                                    docs.json, search-data.json — and their
- *                                    /docs/<name> twins for hostAtDocs sites)
- *
- * MDX pages under /docs/<slug> (hostAtDocs MDX content) ARE rewritten — only
- * the named static endpoints above are excluded.
- */
-export function shouldRewriteIntoDocsGroup(pathname: string): boolean {
-  if (STATIC_ENDPOINT_PATHS.has(pathname)) return false;
-  for (const root of SYSTEM_PATH_ROOTS) {
-    if (isPathOrUnder(pathname, root)) return false;
-  }
-  return true;
-}
-
 /**
  * Result of project resolution.
  */

package/vendored/lib/page-isr-helpers.ts

@@ -159,6 +159,22 @@ export function getBaseUrl(headers: Headers, projectSlug: string, hostAtDocs = f
   return `https://${projectSlug}.jamdesk.app`;
 }
 
+/**
+ * Header-free base URL fallback. Always returns the canonical subdomain
+ * URL (`https://<slug>.jamdesk.app[/docs]`).
+ *
+ * Used when the caller does not have request headers — direct URL params
+ * branch in non-ISR dev/tests, and metadata callers that want a stable
+ * canonical without forcing the segment dynamic. The header-aware variant
+ * `getBaseUrl` should be preferred whenever headers are available so
+ * custom-domain customers see their own host in canonical/OG tags.
+ */
+export function getBaseUrlFromConfig(projectSlug: string, hostAtDocs = false): string {
+  return hostAtDocs
+    ? `https://${projectSlug}.jamdesk.app/docs`
+    : `https://${projectSlug}.jamdesk.app`;
+}
+
 /**
  * Read the active locale from request headers.
  *

package/vendored/lib/project-resolver.ts

@@ -98,11 +98,18 @@ export async function resolveCustomDomain(hostname: string): Promise<DomainResol
 }
 
 /**
- * Get project configuration for a subdomain.
+ * Get project configuration for a subdomain (silent-fallback variant).
  * Used for hostAtDocs setting on *.jamdesk.app domains.
  *
  * Default is hostAtDocs=false for subdomains (serve at root).
  * Projects that need /docs path must explicitly set hostAtDocs=true.
+ *
+ * Swallows Redis errors and returns `{hostAtDocs: false}` so a transient
+ * Redis blip doesn't take down the proxy hot path. Page-side callers
+ * that wrap the result in `unstable_cache` should use
+ * `getProjectConfigStrict` instead — silent-fallback on a cold render
+ * would memoize a wrong `false` for the cache TTL, the exact failure
+ * mode that produced the jamdesk.com/docs/* 404 incident.
  */
 export async function getProjectConfig(projectSlug: string): Promise<{ hostAtDocs: boolean }> {
   if (!redis) {
@@ -119,6 +126,26 @@ export async function getProjectConfig(projectSlug: string): Promise<{ hostAtDoc
   }
 }
 
+/**
+ * Strict variant of `getProjectConfig` — throws on Redis errors instead of
+ * silently returning `{hostAtDocs: false}`. Use this from page-side
+ * `unstable_cache` wrappers so a transient Redis failure during a cold
+ * render produces a 500 (not cached) rather than memoizing a wrong
+ * `false` for the cache TTL.
+ *
+ * A missing `projectCfg:<slug>` key is NOT an error — that's the legitimate
+ * "project hasn't opted into hostAtDocs" case and is safe to cache.
+ */
+export async function getProjectConfigStrict(projectSlug: string): Promise<{ hostAtDocs: boolean }> {
+  if (!redis) {
+    return { hostAtDocs: false };
+  }
+
+  const cfgRaw = await redis.get(`projectCfg:${projectSlug}`);
+  const cfg = parseRedisConfig(cfgRaw);
+  return { hostAtDocs: cfg?.hostAtDocs === true };
+}
+
 /**
  * Full project resolution with custom domain fallback.
  *

package/vendored/lib/r2-content.ts

@@ -19,6 +19,14 @@ export function clearConfigCache(_projectSlug?: string): void {}
 
 export function isR2NotFound(_err: unknown): boolean { return false; }
 
+export function withDataCache<T>(
+  fn: () => Promise<T>,
+  _keyParts: string[],
+  _tags: string[],
+): Promise<T> {
+  return fn();
+}
+
 let fetchDocsConfigWarned = false;
 export async function fetchDocsConfig(_projectSlug: string): Promise<DocsConfig | null> {
   if (!fetchDocsConfigWarned) {