jamdesk 1.1.75 → 1.1.77

package/vendored/lib/render-doc-page.tsx

@@ -34,6 +34,9 @@ import { rehypeClassToClassName } from '@/lib/rehype-class-to-classname';
 import { remarkSvgNamespaceAttrs } from '@/lib/remark-svg-namespace-attrs';
 import { rehypeNoZoomToData } from '@/lib/rehype-nozoom-to-data';
 import { rehypeUnwrapNestedAnchors } from './rehype-unwrap-nested-anchors';
+import { loadSnippetsAndInlineComponents } from './render-doc-page-parallel-helpers';
+import { tryOpenApiCandidatesInParallel, makeTryOpenApiSpec, formatFallbackWarning } from './render-doc-page-openapi-helpers';
+import { logger } from '../shared/logger';
 import { preprocessMdx, containsPanel, containsView, buildSnippetAliasMap } from '@/lib/preprocess-mdx';
 import { loadSnippetsForIsr } from '@/lib/snippet-loader-isr';
 import { PanelWrapper } from '@/components/mdx/PanelWrapper';
@@ -188,6 +191,13 @@ function resolveSlug(normalizedSlug: string[], config: DocsConfig): string[] {
 export async function buildDocMetadata(input: RenderInput): Promise<Metadata> {
   const { slug: slugInput, projectSlug, hostAtDocs, requestHeaders } = input;
 
+  // Middleware sets `x-jd-noindex: true` when serving a hostAtDocs project
+  // directly via *.jamdesk.app and the project has no registered custom
+  // domain yet. The upstream subdomain shouldn't compete with the (yet-to-
+  // arrive) public face in search results — emit robots noindex so Google
+  // skips it. See proxy.ts → projectHeaderOptsForCanonical for the source.
+  const noindexHeader = requestHeaders?.get('x-jd-noindex') === 'true';
+
   if (isIsrMode()) {
     if (!projectSlug) return { title: 'Not Found' };
     const exists = await projectExists(projectSlug);
@@ -229,26 +239,37 @@ export async function buildDocMetadata(input: RenderInput): Promise<Metadata> {
     ? (data.title === config.name ? { absolute: data.title } : data.title)
     : { absolute: buildSiteTitle(config.name) };
 
+  const markdownHref = `${hostAtDocs ? '/docs/' : '/'}${pagePath}.md`;
+
+  // noindexHeader (middleware) and isRoot override frontmatter robots
+  // (already in seoMetadata) via spread order.
+  const robotsOverride =
+    isRoot || noindexHeader
+      ? { robots: { index: false, follow: true } as const }
+      : {};
+
   return {
     title: titleValue,
     description: data.description || '',
     ...seoMetadata,
-    ...(isRoot && { robots: { index: false, follow: true } }),
-    ...(data.rss ? {
-      alternates: {
-        ...seoMetadata.alternates,
-        types: {
+    ...robotsOverride,
+    alternates: {
+      ...seoMetadata.alternates,
+      types: {
+        'text/markdown': markdownHref,
+        ...(data.rss && {
           'application/rss+xml': hostAtDocs ? '/docs/feed.xml' : '/feed.xml',
-        },
+        }),
       },
-    } : {}),
+    },
   };
 }
 
 export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
   const { slug: slugInput, projectSlug, hostAtDocs, requestHeaders } = input;
+  const isIsr = isIsrMode();
 
-  if (isIsrMode()) {
+  if (isIsr) {
     if (!projectSlug) notFound();
     const exists = await projectExists(projectSlug);
     if (!exists) notFound();
@@ -256,6 +277,10 @@ export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
 
   const loader = getContentLoader(projectSlug ?? undefined);
   const configP = loader.getConfig();
+  // Shiki init takes 200-500ms on cold function instances. Kick it off
+  // before the content fetch so the two run concurrently. Warm instances
+  // resolve from the globalThis singleton instantly.
+  const highlighterP = getHighlighter();
 
   const normalizedSlug = normalizeSlugForContent(slugInput || [], hostAtDocs);
   const slug = needsSlugRewrite(normalizedSlug)
@@ -263,9 +288,10 @@ export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
     : normalizedSlug;
   const pagePath = slug.join('/');
   const currentLang = extractLanguageFromPath(`/${pagePath}`);
-  const [fileContents, config] = await Promise.all([
+  const [fileContents, config, highlighter] = await Promise.all([
     loader.getContent(pagePath).catch(() => null),
     configP,
+    highlighterP,
   ]);
 
   if (!fileContents) {
@@ -285,14 +311,14 @@ export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
   });
   const jsonLdScript = renderJsonLdScript(jsonLd);
 
-  const highlighter = await getHighlighter();
+  const openApiSpecField = typeof data.openapi === 'string' && data.openapi ? data.openapi : null;
 
-  let snippetAliases: Record<string, React.ComponentType<unknown>> = {};
-  if (isIsrMode() && projectSlug) {
-    snippetAliases = await loadSnippetsForIsr(projectSlug, rawContent, MDXComponents);
-  } else {
-    snippetAliases = buildSnippetAliasMap(rawContent, SnippetComponents);
-  }
+  // Resolve openapi-isr dynamic import concurrently with the snippet/inline
+  // parallel block. Win is small — one module-resolve, ~5–30ms on a true cold
+  // start, <1ms on warm V8. Kept because the syntactic cost is one ternary.
+  const openApiIsrP = openApiSpecField && isIsr && projectSlug
+    ? import('@/lib/openapi-isr')
+    : null;
 
   const content = preprocessMdx(rawContent, { assetVersion: config.assetVersion });
 
@@ -300,13 +326,29 @@ export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
     .filter(h => typeof h.stepNumber === 'number')
     .map(h => ({ title: h.text, slug: h.id }));
 
-  const { inlineComponents, paramFields } = await extractInlineComponents(content, MDXComponents);
+  // [render-timing] proves the snippet/inline parallel win. With Promise.all,
+  // wall-clock should be ~max(R2_snippets, CPU_inline). Compare against the
+  // per-op `[r2-timing]` for snippet R2: if snippetInlineMs ≈ snippet R2 ms,
+  // inline ran "for free" inside the R2 wait. Sum-of-both = parallelism failed.
+  const snippetInlineStart = performance.now();
+  const { snippetAliases, inlineComponents, paramFields } = await loadSnippetsAndInlineComponents({
+    isIsr,
+    projectSlug: projectSlug ?? null,
+    rawContent,
+    preprocessedContent: content,
+    mdxComponents: MDXComponents,
+    snippetComponents: SnippetComponents,
+    loadSnippets: loadSnippetsForIsr,
+    buildAlias: buildSnippetAliasMap,
+    extractInline: extractInlineComponents,
+  });
+  const snippetInlineMs = Math.round(performance.now() - snippetInlineStart);
 
   const overriddenComponents = Object.keys(inlineComponents).filter(
     (name) => name in MDXComponents,
   );
   if (overriddenComponents.length > 0) {
-    console.warn(
+    logger.warn(
       `[MDX] Inline component(s) override built-in: ${overriddenComponents.join(', ')} in ${slug.join('/')}`,
     );
   }
@@ -339,9 +381,11 @@ export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
   let openApiEndpointData: OpenApiEndpointData | null = null;
   let openApiCodeExamples: CodeExample[] | null = null;
   let openApiError: string | null = null;
+  let openApiMs: number | null = null;
+  let openApiCandidates = 0;
 
   let lastFailure: { err: unknown; specPath: string } | null = null;
-  if (data.openapi && typeof data.openapi === 'string') {
+  if (openApiSpecField) {
     try {
       const openApiConfig = config.api?.openapi;
       const allSpecPaths: string[] = typeof openApiConfig === 'string'
@@ -351,7 +395,7 @@ export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
           : [];
 
       const parsed = parseOpenApiFrontmatter(
-        data.openapi,
+        openApiSpecField,
         allSpecPaths.length > 0 ? allSpecPaths : undefined,
       );
 
@@ -359,43 +403,40 @@ export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
         ? allSpecPaths
         : [parsed.specPath];
       const specsToTry = baseSpecs.flatMap(p => candidateSpecPaths(p, currentLang));
+      openApiCandidates = specsToTry.length;
 
-      const useIsr = isIsrMode() && !!projectSlug;
-      const resolveSpec = useIsr
-        ? (await import('@/lib/openapi-isr')).resolveOpenApiSpec
+      const useIsr = isIsr && !!projectSlug;
+      const resolveSpec = useIsr && openApiIsrP
+        ? (await openApiIsrP).resolveOpenApiSpec
         : null;
       const contentDir = useIsr ? null : getContentDir();
 
-      for (let i = 0; i < specsToTry.length; i++) {
-        const specPath = specsToTry[i];
-        try {
-          if (resolveSpec && projectSlug) {
-            const spec = await resolveSpec(projectSlug, specPath);
-            openApiEndpointData = parseEndpoint(
-              spec as Parameters<typeof parseEndpoint>[0],
-              parsed.method,
-              parsed.path,
-              specPath,
-            );
-          } else {
-            const { api } = await getCachedSpec(specPath, contentDir!);
-            openApiEndpointData = parseEndpoint(api, parsed.method, parsed.path, specPath);
-          }
-          lastFailure = null;
-          break;
-        } catch (err) {
-          lastFailure = { err, specPath };
-          const isLast = i === specsToTry.length - 1;
-          if (!isLast) {
-            console.warn(
-              `[openapi] spec candidate "${specPath}" failed; trying next: ${(err as Error).message}`,
-            );
-          }
-        }
+      const tryOne = makeTryOpenApiSpec({
+        projectSlug: projectSlug ?? null,
+        isIsr: useIsr,
+        parsedMethod: parsed.method,
+        parsedPath: parsed.path,
+        resolveIsrSpec: resolveSpec,
+        getStaticSpec: useIsr ? null : getCachedSpec,
+        contentDir,
+        parseEndpointFn: parseEndpoint,
+      });
+
+      // See `[render-timing]` block above snippetInlineMs for the verification
+      // protocol. Same idea here: openApiMs ≈ max(per-spec R2) = parallel.
+      const openApiStart = performance.now();
+      const result = await tryOpenApiCandidatesInParallel(specsToTry, tryOne);
+      openApiMs = Math.round(performance.now() - openApiStart);
+      if (result.kind === 'success') {
+        openApiEndpointData = result.endpoint;
+        lastFailure = null;
+        const warning = formatFallbackWarning(specsToTry, result.specPath, parsed.method, parsed.path);
+        if (warning) logger.warn(warning);
+      } else {
+        lastFailure = { err: result.lastError, specPath: result.specPath };
+        throw result.lastError;
       }
 
-      if (lastFailure) throw lastFailure.err;
-
       if (openApiEndpointData) {
         const { method: authMethod, headerName: authHeaderName } = resolveAuth(openApiEndpointData, config);
         const languages = config.api?.examples?.languages;
@@ -403,13 +444,21 @@ export async function renderDocPage(input: RenderInput): Promise<ReactElement> {
       }
     } catch (err) {
       const typed = classifyOpenApiLoadError(err, lastFailure?.specPath ?? null);
-      console.warn(formatOpenApiWarning(typed));
+      logger.warn(formatOpenApiWarning(typed));
       openApiError = typed.suggestion
         ? `${typed.message} — ${typed.suggestion}`
         : typed.message;
     }
   }
 
+  logger.info('[render-timing]', {
+    region: process.env.VERCEL_REGION || 'unknown',
+    pagePath,
+    snippetInlineMs,
+    openApiMs,
+    openApiCandidates,
+  });
+
   let mdxApiMethod: HttpMethod | null = null;
   let mdxApiPath: string | null = null;
   if (data.api && typeof data.api === 'string' && !data.openapi) {

package/vendored/lib/sidebar-prefetch-walker.ts

@@ -0,0 +1,50 @@
+import type { ResolvedGroup } from '@/lib/navigation-resolver';
+
+/**
+ * Flatten a resolved navigation tree to the list of hrefs that should be
+ * prefetched under the existing group-engagement rule from Sidebar.tsx:
+ *
+ *   shouldPrefetch = level !== 0 || isExpanded || !group.name
+ *
+ * Children of a level-0 group emit only when that group is expanded.
+ * Children of nameless or deeper-level groups always emit. Order matches
+ * the rendered sidebar so paced prefetches mirror what a user is most
+ * likely to click next.
+ */
+export function getPrefetchableHrefs(
+  groups: ResolvedGroup[],
+  expandedGroups: Set<string>,
+  linkPrefix: string,
+  level: number = 0,
+): string[] {
+  const out: string[] = [];
+  const walk = (groups: ResolvedGroup[], level: number) => {
+    for (const group of groups) {
+      const isExpanded = expandedGroups.has(group.name);
+      const groupOpen = level !== 0 || isExpanded || !group.name;
+      if (!groupOpen) continue;
+
+      if (group.items) {
+        for (const item of group.items) {
+          if (item.type === 'page') {
+            out.push(`${linkPrefix}/${item.page.path}`);
+          } else if (item.type === 'group') {
+            walk([item.group], level + 1);
+          }
+        }
+      } else {
+        for (const page of group.pages) {
+          out.push(`${linkPrefix}/${page.path}`);
+        }
+        if (group.nested) walk(group.nested, level + 1);
+      }
+    }
+  };
+  walk(groups, level);
+
+  // Dedup: a docs.json config can reference the same page from two groups
+  // (uncommon but legal). Without this, the pacer fires router.prefetch()
+  // twice for the same href since scheduleNext walks the items array
+  // literally and `seen` is populated up-front, not within the chain.
+  return Array.from(new Set(out));
+}

package/vendored/lib/static-artifacts.ts

@@ -170,7 +170,8 @@ Disallow: /
   return `User-agent: *
 Allow: /
 
-Disallow: /_next/
+Allow: /_next/static/
+Allow: /_next/image
 
 Sitemap: ${sitemapUrl || defaultSitemapUrl}
 `;