jamdesk 1.1.75 → 1.1.77

package/vendored/components/mdx/ApiPage.tsx

@@ -1,6 +1,7 @@
 'use client';
 
 import { ReactNode, useEffect, useRef, useState, useCallback } from 'react';
+import { CODEPANEL_TAB_CHANGE_EVENT } from '@/components/ui/CodePanel';
 
 interface ApiPageWrapperProps {
   children: ReactNode;
@@ -28,6 +29,13 @@ function countCodeLines(panel: Element): number {
   const codeContent = panel.querySelector('div.grid.grid-cols-\\[minmax\\(0\\,1fr\\)\\]');
   if (!codeContent) return 0;
 
+  // Loading state: reserve space so the spinner is visible. CodePanel re-fires
+  // codepanel-tab-change when the highlighted HTML arrives, which invalidates
+  // the cached measurement and brings us back through here for a real count.
+  if (codeContent.querySelector('[aria-busy="true"]')) {
+    return CODE_BOX_CONFIG.MIN_LINES;
+  }
+
   // Check for Shiki-rendered code (has pre.shiki)
   const shikiPre = codeContent.querySelector('pre.shiki');
   if (shikiPre) {
@@ -375,8 +383,8 @@ export function ApiPageWrapper({ children }: ApiPageWrapperProps) {
     };
 
     const sidebar = sidebarRef.current;
-    sidebar.addEventListener('codepanel-tab-change', handleTabChange);
-    return () => sidebar.removeEventListener('codepanel-tab-change', handleTabChange);
+    sidebar.addEventListener(CODEPANEL_TAB_CHANGE_EVENT, handleTabChange);
+    return () => sidebar.removeEventListener(CODEPANEL_TAB_CHANGE_EVENT, handleTabChange);
   }, [isDesktop, mounted, applyPanelHeights]);
 
   return (

package/vendored/components/mdx/OpenApiEndpoint.tsx

@@ -4,10 +4,7 @@ import { useDevOnlyNotice, DEV_FEATURE } from '../ui/DevOnlyNotice';
 
 import { useState, useEffect, useMemo } from 'react';
 import { ApiEndpoint } from './ApiEndpoint';
-import { ParamField } from './ParamField';
-import { CodeGroup } from './CodeGroup';
-import { Tabs, Tab } from './Tabs';
-import { CodePanel, CodePanelTab, getStatusColor } from '../ui/CodePanel';
+import { CodePanel, CodePanelTab, DelayedSpinner } from '../ui/CodePanel';
 import { useShikiHighlightMultiple } from '@/hooks/useShikiHighlight';
 import { preloadHighlighter } from '@/lib/shiki-client';
 import ReactMarkdown from 'react-markdown';
@@ -76,16 +73,17 @@ function renderSchemaType(schema: JsonSchema): string {
   return type || 'any';
 }
 
+// Shiki HTML comes from server-side highlighting of trusted code strings;
+// sanitization is unnecessary and would break the syntax-color spans.
+function renderHighlightedHtml(html: string) {
+  // eslint-disable-next-line react/no-danger
+  return <div dangerouslySetInnerHTML={{ __html: html }} />;
+}
+
 /**
  * Render nested schema properties as a list of field items
  */
-function SchemaProperties({
-  schema,
-  depth = 0
-}: {
-  schema: JsonSchema;
-  depth?: number;
-}) {
+function SchemaProperties({ schema }: { schema: JsonSchema }) {
   if (!schema.properties || Object.keys(schema.properties).length === 0) {
     return null;
   }
@@ -596,21 +594,26 @@ function ResponseExamplePanel({
     codeItems.map((item) => ({ code: item.jsonStr, language: item.language }))
   );
 
-  // Build tabs for CodePanel - render full Shiki HTML for theme background support
+  // While Shiki resolves, tab body shows a delayed spinner — without the
+  // isLoading guard we'd flash the hook's escapeHtml placeholder. CodePanel
+  // must mount once with a stable [data-code-panel] (see DelayedSpinner in
+  // CodePanel.tsx for the hoist constraint that forced this shape).
   const tabs: CodePanelTab[] = useMemo(
     () =>
-      codeItems.map((item, index) => ({
-        label: item.code,
-        statusCode: item.code,
-        content: (
-          <div dangerouslySetInnerHTML={{ __html: highlightedResults[index] || '' }} />
-        ),
-      })),
-    [codeItems, highlightedResults]
+      codeItems.map((item, index) => {
+        const html = highlightedResults[index];
+        return {
+          label: item.code,
+          statusCode: item.code,
+          content: !isLoading && html
+            ? renderHighlightedHtml(html)
+            : <DelayedSpinner />,
+        };
+      }),
+    [codeItems, highlightedResults, isLoading]
   );
 
-  // Don't render until highlighting is complete to prevent flash of unformatted content
-  if (tabs.length === 0 || isLoading) return null;
+  if (tabs.length === 0) return null;
 
   return (
     <CodePanel
@@ -703,13 +706,11 @@ function FieldConstraints({ schema }: { schema: JsonSchema }) {
  * Response fields list with parent prefix for nested fields
  * Handles typical API response schemas like { properties: { conference: { type: 'array', items: {...} } } }
  */
-function ResponseFieldsList({ 
-  schema, 
-  depth = 0,
+function ResponseFieldsList({
+  schema,
   parentName = ''
-}: { 
-  schema: JsonSchema; 
-  depth?: number;
+}: {
+  schema: JsonSchema;
   parentName?: string;
 }) {
   // If no properties to show, return null
@@ -729,7 +730,6 @@ function ResponseFieldsList({
           parentName={parentName}
           isRequired={required.has(name)}
           isFirst={index === 0}
-          depth={depth}
         />
       ))}
     </div>
@@ -745,14 +745,12 @@ function ResponseFieldItem({
   parentName,
   isRequired,
   isFirst,
-  depth
 }: {
   name: string;
   schema: JsonSchema;
   parentName: string;
   isRequired: boolean;
   isFirst: boolean;
-  depth: number;
 }) {
   const [expanded, setExpanded] = useState(true);
   
@@ -862,20 +860,21 @@ function CodeExamplesSection({ examples }: { examples: CodeExample[] }) {
 
   const { results: highlightedResults, isLoading } = useShikiHighlightMultiple(codeItems);
 
-  // Shiki generates HTML from trusted code strings (not user input)
+  // While Shiki resolves, tab body shows a delayed spinner — without the
+  // isLoading guard we'd flash the hook's escapeHtml placeholder.
   const tabs: CodePanelTab[] = useMemo(
-    () => examples.map((ex, i) => ({
-      label: ex.label,
-      content: highlightedResults[i]
-        ? <div dangerouslySetInnerHTML={{ __html: highlightedResults[i] }} />
-        : null,
-    })),
-    [examples, highlightedResults]
+    () => examples.map((ex, i) => {
+      const html = highlightedResults[i];
+      return {
+        label: ex.label,
+        content: !isLoading && html
+          ? renderHighlightedHtml(html)
+          : <DelayedSpinner />,
+      };
+    }),
+    [examples, highlightedResults, isLoading]
   );
 
-  // Don't render until highlighting is complete to prevent flash of unformatted content
-  if (isLoading) return null;
-
   return <CodePanel tabs={tabs} variant="compact" panelType="request" enableFullscreen />;
 }
 
@@ -883,7 +882,6 @@ function CodeExamplesSection({ examples }: { examples: CodeExample[] }) {
  * OpenAPI Endpoint Component
  * 
  * Renders full endpoint documentation from OpenAPI spec data.
- * Composes existing ParamField, ResponseField, and CodeGroup components.
  */
 export function OpenApiEndpoint({
   endpoint,
@@ -900,7 +898,6 @@ export function OpenApiEndpoint({
   const {
     method,
     path,
-    summary,
     description,
     deprecated,
     parameters,

package/vendored/components/mdx/YouTube.tsx

@@ -1,4 +1,5 @@
 import type React from 'react';
+import { preconnect } from 'react-dom';
 import { YouTubeEmbed } from '@next/third-parties/google';
 
 interface YouTubeProps {
@@ -26,6 +27,7 @@ export function YouTube({ id, title, start, short }: YouTubeProps): React.ReactE
   const params = startSeconds ? `rel=0&start=${startSeconds}` : 'rel=0';
 
   if (short) {
+    preconnect('https://www.youtube.com');
     const src = `https://www.youtube.com/embed/${id}?${params}`;
     return (
       <div className="my-6 mx-auto max-w-[360px]">
@@ -41,6 +43,12 @@ export function YouTube({ id, title, start, short }: YouTubeProps): React.ReactE
     );
   }
 
+  // No crossOrigin — @next/third-parties loads the lite-yt-embed stylesheet
+  // and script in no-CORS mode, so a CORS-anonymous preconnect would open a
+  // separate connection pool those fetches can't reuse.
+  preconnect('https://i.ytimg.com');
+  preconnect('https://cdn.jsdelivr.net');
+
   return (
     <div className="my-6 [&_lite-youtube]:rounded-xl [&_lite-youtube]:overflow-hidden">
       <YouTubeEmbed

package/vendored/components/navigation/Sidebar.tsx

@@ -44,11 +44,11 @@ interface NavPageProps {
   layout: LayoutVariant;
   onNavigate: (href: string) => void;
   linkPrefix?: string; // e.g., '/docs' when hostAtDocs is true
-  prefetch?: boolean;
   showSpinner?: boolean;
+  prefetch?: boolean;
 }
 
-export const NavPage = React.memo(function NavPage({ page, pathname, layout, onNavigate, linkPrefix = '', prefetch = true, showSpinner = false }: NavPageProps) {
+export const NavPage = React.memo(function NavPage({ page, pathname, layout, onNavigate, linkPrefix = '', showSpinner = false, prefetch = true }: NavPageProps) {
   const href = `${linkPrefix}/${page.path}`;
   const isActive = pathname === href;
   const colors = page.method ? methodColors[page.method] : null;
@@ -58,7 +58,14 @@ export const NavPage = React.memo(function NavPage({ page, pathname, layout, onN
       <Link
         href={href}
         prefetch={prefetch}
-        onClick={() => onNavigate(href)}
+        onClick={(e) => {
+          // Modifier-clicks open the link in a new tab — current tab does
+          // NOT navigate, so don't mark a navigation pending. We only need
+          // to filter modifier keys: middle-click on an <a> dispatches
+          // `auxclick`, not `click`, so it never reaches this handler.
+          if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+          onNavigate(href);
+        }}
         className={`flex items-center gap-2 ${layout === 'header-logo' ? 'pr-3' : 'px-3'} py-1.5 rounded-lg text-sm transition-colors ${
           isActive
             ? 'text-[var(--color-primary)] nav-active'
@@ -163,6 +170,14 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
     rawNavigate(url);
   }, [rawNavigate]);
 
+  // Buttons (group header, anchor, tab) need router.push because they're
+  // not <Link>s — Link's own click handler does the navigation, buttons must.
+  const handleButtonNav = useCallback((url: string) => {
+    userInitiatedNavRef.current = true;
+    rawNavigate(url);
+    router.push(url);
+  }, [rawNavigate, router]);
+
   const effectivePathname = pendingPathname || pathname;
 
   // Determine effective tabsPosition:
@@ -324,23 +339,27 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
     });
     if (willExpand) {
       const firstPagePath = findFirstPageInGroups([group]);
-      if (firstPagePath) router.push(`${linkPrefix}/${firstPagePath}`);
+      if (firstPagePath) {
+        handleButtonNav(`${linkPrefix}/${firstPagePath}`);
+      }
     }
-  }, [router, linkPrefix, expandedGroups]);
+  }, [linkPrefix, expandedGroups, handleButtonNav]);
 
   // Render a navigation group (supports nesting)
   function renderGroup(group: ResolvedGroup, level: number = 0) {
     const isExpanded = expandedGroups.has(group.name);
-    // expandedGroups starts empty and is populated in a useEffect, so the very
-    // first render has shouldPrefetch=false for every L0 section; Next.js
-    // re-schedules the prefetch when the prop flips to true on the next commit.
-    const shouldPrefetch = level !== 0 || isExpanded || !group.name;
 
     // Skip rendering if group has no name and no content
     if (!group.name && group.pages.length === 0 && !group.nested?.length && !group.items?.length) {
       return null;
     }
 
+    // Don't fan out RSC prefetches for collapsed L0 sections on large docs
+    // sites. L1+ Links are only in the DOM when their named ancestors are
+    // expanded (see the rendering guard below), so `level !== 0` is safe
+    // shorthand there.
+    const shouldPrefetch = level !== 0 || isExpanded || !group.name;
+
     return (
       <div key={group.name || `group-${level}`} className={level === 0 ? 'ml-6' : level === 1 ? '' : 'ml-3'}>
         {group.name && (
@@ -402,8 +421,8 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
                               layout={layout}
                               onNavigate={handleNavigate}
                               linkPrefix={linkPrefix}
-                              prefetch={shouldPrefetch}
                               showSpinner={spinnerPathname === `${linkPrefix}/${p.page.path}`}
+                              prefetch={shouldPrefetch}
                             />
                           ))}
                         </ul>
@@ -442,8 +461,8 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
                         layout={layout}
                         onNavigate={handleNavigate}
                         linkPrefix={linkPrefix}
-                        prefetch={shouldPrefetch}
                         showSpinner={spinnerPathname === `${linkPrefix}/${page.path}`}
+                        prefetch={shouldPrefetch}
                       />
                     ))}
                   </ul>
@@ -495,9 +514,7 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
               data-nav-anchor
               data-active={isCurrentAnchor ? 'true' : 'false'}
               onClick={() => {
-                if (firstPagePath) {
-                  router.push(`${linkPrefix}/${firstPagePath}`);
-                }
+                if (firstPagePath) handleButtonNav(`${linkPrefix}/${firstPagePath}`);
               }}
               className={`flex items-center gap-2.5 ml-6 pr-3 py-1.5 text-sm font-medium transition-colors cursor-pointer ${
                 isCurrentAnchor
@@ -606,9 +623,7 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
             <button
               key={tab.name}
               onClick={() => {
-                if (firstPagePath) {
-                  router.push(`${linkPrefix}/${firstPagePath}`);
-                }
+                if (firstPagePath) handleButtonNav(`${linkPrefix}/${firstPagePath}`);
               }}
               className={`nav-tab-link flex items-center gap-2 px-3 py-1.5 text-sm transition-colors cursor-pointer ${
                 isActive

package/vendored/components/navigation/TabsNav.tsx

@@ -5,7 +5,7 @@ import Link from 'next/link';
 import { usePathname } from 'next/navigation';
 // Icons use Font Awesome CSS classes for lightweight rendering
 import type { DocsConfig, TabsPosition } from '@/lib/docs-types';
-import { resolveNavigation, type ResolvedTab, type ResolvedGroup } from '@/lib/navigation-resolver';
+import { resolveNavigation } from '@/lib/navigation-resolver';
 import { getIconClass } from '@/lib/icon-utils';
 import { getTheme } from '@/themes';
 import { getTabsFromConfig } from '@/lib/navigation-utils';
@@ -24,38 +24,25 @@ export function TabsNav({ config, className = '' }: TabsNavProps) {
   const themeConfig = getTheme(config.theme);
   const effectiveTabsPosition: TabsPosition = config.tabsPosition || themeConfig.defaultTabsPosition;
 
-  // TabsNav is only for 'top' position - when tabs should appear below header
-  // When tabsPosition is 'left', tabs are rendered in the Sidebar instead
-  if (effectiveTabsPosition !== 'top') {
-    return null;
-  }
-
   // Resolve navigation to get tabs and their content
   const resolved = useMemo(() => resolveNavigation(config, pathname), [config, pathname]);
 
-  // Get tabs from config (handles both standard and multi-language formats)
-  const configTabs = getTabsFromConfig(config, pathname);
+  // Memoize so the tabsWithPaths memo's deps stay stable across renders.
+  const configTabs = useMemo(() => getTabsFromConfig(config, pathname), [config, pathname]);
 
-  // Only render if we have tabs
-  if (configTabs.length === 0) {
-    return null;
-  }
-
-  // Build tab data with first page paths for linking
+  // Build tab data with first page paths for linking. Skip the work when
+  // tabsPosition isn't 'top' — we'd return null below anyway, but the
+  // useMemo must run unconditionally for rules-of-hooks.
   const tabsWithPaths = useMemo(() => {
-    const tabs = configTabs;
-    
-    return tabs.map((tab, index) => {
+    if (effectiveTabsPosition !== 'top') return [];
+
+    return configTabs.flatMap((tab, index) => {
       const resolvedTab = resolved.tabs[index];
-      
-      // Get groups for this tab to find first page and check active state
-      const tabGroups: ResolvedGroup[] = [];
-      if (tab.groups) {
-        // Need to resolve groups from the original tab config
-        // For now, we'll look them up in resolved.groups
-        // This is a simplification - in a full implementation we'd track per-tab groups
-      }
-      
+      // configTabs and resolved.tabs select the active language independently;
+      // their fallbacks for empty-tab languages differ, so guard against
+      // length mismatch rather than throw on `.isExternal` of undefined.
+      if (!resolvedTab) return [];
+
       // For external tabs, use the href directly
       if (resolvedTab.isExternal && resolvedTab.href) {
         return {
@@ -132,9 +119,14 @@ export function TabsNav({ config, className = '' }: TabsNavProps) {
         isActive,
       };
     });
-  }, [configTabs, resolved.tabs, pathname, linkPrefix]);
-  
-  // If only one tab, don't show tabs nav
+  }, [configTabs, resolved.tabs, pathname, linkPrefix, effectiveTabsPosition]);
+
+  // TabsNav is only for 'top' position - when tabs should appear below header
+  // When tabsPosition is 'left', tabs are rendered in the Sidebar instead
+  if (effectiveTabsPosition !== 'top') {
+    return null;
+  }
+
   if (tabsWithPaths.length <= 1) {
     return null;
   }

package/vendored/components/ui/CodePanel.tsx

@@ -42,6 +42,9 @@ export interface CodePanelProps {
   className?: string;
 }
 
+// Bubbles up to the ApiPage sidebar listener; load-bearing for resize-on-content-change.
+export const CODEPANEL_TAB_CHANGE_EVENT = 'codepanel-tab-change';
+
 /**
  * CSS color variables with hardcoded fallbacks
  * Themes can override via --code-panel-* variables
@@ -150,10 +153,13 @@ export function CodePanel({
     }
   };
 
-  // Notify parent (ApiPage) after tab content re-renders so sidebar heights recalculate
+  // ApiPage caches each panel's line count on first measure; we re-fire on
+  // active-tab content change so the spinner-era height is invalidated when
+  // async Shiki finishes.
+  const currentTabContent = tabs[activeTab]?.content;
   useEffect(() => {
-    panelRef.current?.dispatchEvent(new CustomEvent('codepanel-tab-change', { bubbles: true }));
-  }, [activeTab]);
+    panelRef.current?.dispatchEvent(new CustomEvent(CODEPANEL_TAB_CHANGE_EVENT, { bubbles: true }));
+  }, [activeTab, currentTabContent]);
 
   // Check for overflow and scroll position
   useEffect(() => {
@@ -255,6 +261,8 @@ export function CodePanel({
       ref={panelRef}
       className={`rounded-xl overflow-hidden not-prose w-full flex flex-col ${className}`}
       style={{ border: `0.5px solid ${codePanelColors.border}`, boxShadow: 'var(--shadow-lg)' }}
+      // Load-bearing: ApiPage's MutationObserver hoists [data-code-panel]
+      // into the sticky right column. Don't drop or rename this attribute.
       data-code-panel={panelType || 'inline'}
     >
       {/* Tabs header - flex-shrink-0 to maintain size */}
@@ -522,3 +530,40 @@ export function CodePanel({
     </div>
   );
 }
+
+interface DelayedSpinnerProps {
+  /** Delay before showing the spinner — avoids flash on fast loads. */
+  delayMs?: number;
+  /** Min body height to reserve so layout doesn't jump on first paint. */
+  minHeight?: number;
+}
+
+// Use this as `content` of a CodePanel tab while async work resolves. Earlier
+// versions had a separate CodePanelSkeleton component, but ApiPage's
+// MutationObserver hoists `[data-code-panel]` nodes into the sticky sidebar
+// — when React then tried to unmount the skeleton from prose, the node was
+// already in the sidebar and removeChild threw NotFoundError. Swapping tab
+// content keeps the outer `[data-code-panel]` mounted so the hoist happens
+// exactly once.
+export function DelayedSpinner({ delayMs = 500, minHeight = 60 }: DelayedSpinnerProps) {
+  const [show, setShow] = useState(false);
+  useEffect(() => {
+    const t = setTimeout(() => setShow(true), delayMs);
+    return () => clearTimeout(t);
+  }, [delayMs]);
+
+  return (
+    <div
+      className="flex items-center justify-center py-3"
+      style={{ minHeight, color: codePanelColors.textMuted }}
+      aria-busy="true"
+      aria-live="polite"
+    >
+      <i
+        className={`fa-solid fa-circle-notch fa-spin text-base transition-opacity duration-200 ${show ? 'opacity-60' : 'opacity-0'}`}
+        aria-hidden="true"
+      />
+      <span className="sr-only">Loading code example</span>
+    </div>
+  );
+}

package/vendored/hooks/useIsNavigationSettled.ts

@@ -0,0 +1,74 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+
+// setTimeout(0) yields one frame so the page's initial RSC paint commits
+// before the prefetch chain kicks off.
+export const SETTLED_DELAY_MS = 0;
+
+/**
+ * Boolean signal: "is it safe to prefetch sidebar links right now?"
+ *
+ * True iff:
+ *   - pendingPathname is null (no click-in-flight), AND
+ *   - document.readyState === 'complete', AND
+ *   - one frame has elapsed since the last pathname change (setTimeout 0).
+ *
+ * Resets to false on any input change. The setTimeout(0) frame yield lets
+ * the page's initial RSC render commit before we kick off the prefetch
+ * chain — without it, sidebar prefetches can race the page's own data
+ * fetches inside the same Vercel function pool.
+ */
+export function useIsNavigationSettled(
+  pathname: string | null,
+  pendingPathname: string | null,
+): boolean {
+  const [settled, setSettled] = useState(false);
+
+  useEffect(() => {
+    setSettled(false);
+
+    if (typeof document === 'undefined') return;
+
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+    const startTimer = () => {
+      timeoutId = setTimeout(() => {
+        setSettled(true);
+      }, SETTLED_DELAY_MS);
+    };
+
+    const cleanup = () => {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+
+    // Don't pace until the user has nothing pending and the page has loaded.
+    if (pendingPathname !== null) {
+      return cleanup;
+    }
+
+    if (document.readyState === 'complete') {
+      startTimer();
+      return cleanup;
+    }
+
+    // Wait for the load event, then start the stability timer.
+    const onLoad = () => {
+      window.removeEventListener('load', onLoad);
+      startTimer();
+    };
+    window.addEventListener('load', onLoad);
+
+    return () => {
+      window.removeEventListener('load', onLoad);
+      cleanup();
+    };
+    // pathname dep handles back/forward and deep-link navs that bypass
+    // the click handlers (no pendingPathname flip).
+  }, [pathname, pendingPathname]);
+
+  return settled;
+}

package/vendored/lib/layout-helpers.tsx

@@ -25,6 +25,7 @@ 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';
+import { fetchCustomCss, fetchCustomJs } from '@/lib/r2-content';
 
 const scrollLockBootstrap = `
 (function() {
@@ -76,6 +77,32 @@ export function getLocalFileContent(filename: string): string | null {
   return null;
 }
 
+interface LoadCustomAssetsInput {
+  projectSlug: string;
+  hasCustomCss: boolean;
+  hasCustomJs: boolean;
+}
+
+interface LoadedCustomAssets {
+  customCss: string | null;
+  customJs: string | null;
+}
+
+/**
+ * Both fetches run in parallel — sequential awaits add one cross-continent
+ * R2 RTT in non-NA regions (~340ms fra1, ~550ms sin1).
+ */
+export async function loadCustomAssets({
+  projectSlug,
+  hasCustomCss,
+  hasCustomJs,
+}: LoadCustomAssetsInput): Promise<LoadedCustomAssets> {
+  const cssP = hasCustomCss ? fetchCustomCss(projectSlug) : Promise.resolve(null);
+  const jsP = hasCustomJs ? fetchCustomJs(projectSlug) : Promise.resolve(null);
+  const [customCss, customJs] = await Promise.all([cssP, jsP]);
+  return { customCss, customJs };
+}
+
 export function getThemeCssContent(themeName: ThemeName | undefined): string | null {
   try {
     const theme = getTheme(themeName);