jamdesk 1.1.170 → 1.1.172

package/vendored/components/navigation/Sidebar.tsx

@@ -433,13 +433,28 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
   // Prevent body scroll when sidebar is open on mobile
   useBodyScrollLock(isOpen);
 
-  // Toggle group expansion; if expanding, navigate to first page. Top-level
-  // sections never visually collapse — for them the toggled key only gates
-  // prefetch (see renderGroupContents) while the click still navigates.
+  // Top-level section titles never collapse; clicking one navigates to the
+  // section's first page. The key is still marked expanded so the section's
+  // Links upgrade to prefetch (see renderGroupContents).
   // The router.push must run AFTER the setState commits — calling it inside the
   // updater triggers "Cannot update a component (Router) while rendering Sidebar".
-  const handleGroupClick = useCallback((group: ResolvedGroup, key: string) => {
-    const willExpand = !expandedGroups.has(key);
+  const handleTopLevelGroupClick = useCallback((group: ResolvedGroup, key: string) => {
+    setExpandedGroups(prev => {
+      if (prev.has(key)) return prev;
+      const newSet = new Set(prev);
+      newSet.add(key);
+      return newSet;
+    });
+    const firstPagePath = findFirstPageInGroups([group]);
+    if (firstPagePath) {
+      handleButtonNav(`${linkPrefix}/${firstPagePath}`);
+    }
+  }, [linkPrefix, handleButtonNav]);
+
+  // Toggle a nested group's accordion. Expanding only reveals the pages —
+  // navigation happens when the visitor clicks a page link, never on the
+  // caret itself.
+  const handleGroupClick = useCallback((key: string) => {
     setExpandedGroups(prev => {
       const newSet = new Set(prev);
       if (prev.has(key)) {
@@ -449,13 +464,7 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
       }
       return newSet;
     });
-    if (willExpand) {
-      const firstPagePath = findFirstPageInGroups([group]);
-      if (firstPagePath) {
-        handleButtonNav(`${linkPrefix}/${firstPagePath}`);
-      }
-    }
-  }, [linkPrefix, expandedGroups, handleButtonNav]);
+  }, []);
 
   // Render the pages and nested groups inside a group. Split out from
   // renderGroup so a named group can gate its contents behind an expanded panel
@@ -574,7 +583,7 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
           {group.name && (
             <button
               type="button"
-              onClick={() => handleGroupClick(group, key)}
+              onClick={() => handleTopLevelGroupClick(group, key)}
               className="flex items-center justify-between w-full text-left mb-2 cursor-pointer"
             >
               <span className="text-sm font-semibold text-[var(--color-text-tertiary)] flex items-center gap-2">
@@ -606,7 +615,7 @@ export function Sidebar({ config, layout = 'header-logo', tabsPosition: tabsPosi
             type="button"
             aria-expanded={isExpanded}
             aria-controls={panelId}
-            onClick={() => handleGroupClick(group, key)}
+            onClick={() => handleGroupClick(key)}
             className={buttonClassName}
           >
             {group.icon && (

package/vendored/lib/ai-service-urls.ts

@@ -0,0 +1,8 @@
+export const AI_CHAT_URLS = {
+  chatgptSearch: 'https://chatgpt.com/?hints=search&q=',
+  chatgpt: 'https://chatgpt.com/?q=',
+  claude: 'https://claude.ai/new?q=',
+  gemini: 'https://gemini.google.com/app?q=',
+  perplexity: 'https://www.perplexity.ai/?q=',
+  cursor: 'https://cursor.com/link/prompt?text=',
+} as const;

package/vendored/lib/build/error-parser.ts

@@ -262,7 +262,7 @@ export function parseErrorDetails(
     const requiredFields =
       'Required fields:\n' +
       '• "name": Your site name\n' +
-      '• "theme": One of "jam", "nebula", or "pulsar"\n' +
+      '• "theme": One of "jam", "nebula", "pulsar", or "halo"\n' +
       '• "colors": { "primary": "#hexcolor" }\n' +
       '• "navigation": one of "tabs", "groups", "pages", "dropdowns", ' +
       '"versions", "languages", or "products" ' +

package/vendored/lib/docs-types.ts

@@ -23,7 +23,7 @@ export const ASSET_PREFIX = '/_jd';
 /**
  * Available themes
  */
-export type ThemeName = 'jam' | 'nebula' | 'pulsar';
+export type ThemeName = 'jam' | 'nebula' | 'pulsar' | 'halo';
 
 // =============================================================================
 // ICON TYPES
@@ -875,8 +875,8 @@ export interface DocsConfig {
   logo?: Logo;
 
   // Tab position - controls where tabs are displayed
-  // 'top': Tabs in header/tab bar (default for pulsar)
-  // 'left': Tabs at top of sidebar (default for jam/nebula)
+  // 'top': Tabs in header/tab bar
+  // 'left': Tabs at top of sidebar (default for every theme)
   tabsPosition?: TabsPosition;
 
   // External link anchors - appear at top of sidebar on all pages

package/vendored/lib/extract-highlights.ts

@@ -11,7 +11,7 @@ import type { DocsConfig } from './docs-types.js';
  */
 export interface ExtractedHighlights {
   siteName: string;
-  theme: 'jam' | 'nebula' | 'pulsar';
+  theme: 'jam' | 'nebula' | 'pulsar' | 'halo';
   primaryColor?: string;
   seoIndexable: boolean;
   analyticsIntegrations: string[];

package/vendored/lib/inject-prompt-source.ts

@@ -0,0 +1,259 @@
+import { createProcessor } from '@mdx-js/mdx';
+import { applyJsxSyntaxFixes } from './mdx-syntax-fixes';
+import { encodePromptSource } from './prompt-source-codec';
+
+type Positioned = {
+  start?: { offset?: number };
+  end?: { offset?: number };
+};
+
+type MdxAttribute = {
+  type?: string;
+  name?: string | null;
+  value?: unknown;
+  position?: Positioned;
+};
+
+type MdxNode = {
+  type?: string;
+  name?: string | null;
+  attributes?: MdxAttribute[];
+  children?: MdxNode[];
+  position?: Positioned;
+};
+
+type OffsetEdit = {
+  start: number;
+  end: number;
+  replacement: string;
+};
+
+function offsetAt(
+  value: number | undefined,
+  description: string,
+): number {
+  if (typeof value !== 'number') {
+    throw new Error(`Missing ${description} offset`);
+  }
+  return value;
+}
+
+function nodeStart(node: MdxNode): number {
+  return offsetAt(node.position?.start?.offset, 'node start');
+}
+
+function nodeEnd(node: MdxNode): number {
+  return offsetAt(node.position?.end?.offset, 'node end');
+}
+
+function isMdxElement(node: MdxNode, name: string): boolean {
+  return (
+    (node.type === 'mdxJsxFlowElement' ||
+      node.type === 'mdxJsxTextElement') &&
+    node.name === name
+  );
+}
+
+function openingInsertionOffset(source: string, node: MdxNode): number {
+  const start = nodeStart(node);
+  const name = node.name;
+  if (!name) throw new Error('Element name is missing');
+
+  const attributes = node.attributes ?? [];
+  const anchor = attributes.length > 0
+    ? offsetAt(
+      attributes[attributes.length - 1].position?.end?.offset,
+      'attribute end',
+    )
+    : start + 1 + name.length;
+  const remainder = source.slice(anchor, nodeEnd(node));
+  if (!/^\s*\/?>/.test(remainder)) {
+    throw new Error('Opening tag delimiter was not found after attributes');
+  }
+  return anchor;
+}
+
+function openingTagEnd(source: string, node: MdxNode): number {
+  const anchor = openingInsertionOffset(source, node);
+  const delimiter = source.slice(anchor, nodeEnd(node)).match(/^\s*\/?>/);
+  if (!delimiter) throw new Error('Opening tag delimiter is missing');
+  return anchor + delimiter[0].length;
+}
+
+function closingTagRange(
+  source: string,
+  node: MdxNode,
+): { start: number; end: number } | null {
+  const start = nodeStart(node);
+  const openEnd = openingTagEnd(source, node);
+  if (source.slice(start, openEnd).trimEnd().endsWith('/>')) return null;
+
+  const end = nodeEnd(node);
+  const tail = source.slice(openEnd, end);
+  const closingStartInTail = tail.lastIndexOf('</Visibility');
+  if (closingStartInTail < 0) {
+    throw new Error('Visibility closing tag is missing');
+  }
+  const closingStart = openEnd + closingStartInTail;
+  if (!/^<\/Visibility\s*>$/.test(source.slice(closingStart, end))) {
+    throw new Error('Visibility closing tag is malformed');
+  }
+  return { start: closingStart, end };
+}
+
+function visibilityIsHidden(node: MdxNode): boolean {
+  let audience: string | null = null;
+  let audienceIsUnknown = false;
+
+  for (const attribute of node.attributes ?? []) {
+    if (attribute.type === 'mdxJsxExpressionAttribute') {
+      audience = null;
+      audienceIsUnknown = true;
+      continue;
+    }
+    if (attribute.type !== 'mdxJsxAttribute') {
+      throw new Error('Unknown Visibility attribute shape');
+    }
+    if (attribute.name !== 'for') continue;
+
+    if (typeof attribute.value === 'string') {
+      audience = attribute.value;
+      audienceIsUnknown = false;
+    } else if (attribute.value === null) {
+      audience = null;
+      audienceIsUnknown = false;
+    } else {
+      audience = null;
+      audienceIsUnknown = true;
+    }
+  }
+
+  return audienceIsUnknown || audience === 'agents';
+}
+
+function collectVisibilityEdits(
+  source: string,
+  node: MdxNode,
+  edits: OffsetEdit[],
+): void {
+  if (isMdxElement(node, 'Visibility')) {
+    if (visibilityIsHidden(node)) {
+      edits.push({ start: nodeStart(node), end: nodeEnd(node), replacement: '' });
+      return;
+    }
+
+    const openEnd = openingTagEnd(source, node);
+    edits.push({ start: nodeStart(node), end: openEnd, replacement: '' });
+    const closing = closingTagRange(source, node);
+    if (closing) edits.push({ ...closing, replacement: '' });
+  }
+
+  node.children?.forEach((child) => {
+    collectVisibilityEdits(source, child, edits);
+  });
+}
+
+function promptBodySource(source: string, prompt: MdxNode): string {
+  const children = prompt.children ?? [];
+  if (children.length === 0) return '';
+
+  const start = children[0].position?.start?.offset;
+  const end = children[children.length - 1].position?.end?.offset;
+  const promptStart = prompt.position?.start?.offset;
+  const promptEnd = prompt.position?.end?.offset;
+  if (
+    typeof start !== 'number' ||
+    typeof end !== 'number' ||
+    typeof promptStart !== 'number' ||
+    typeof promptEnd !== 'number' ||
+    start < promptStart ||
+    end < start ||
+    end > promptEnd ||
+    promptStart < 0 ||
+    promptEnd > source.length
+  ) {
+    return '';
+  }
+  const edits: OffsetEdit[] = [];
+  children.forEach((child) => collectVisibilityEdits(source, child, edits));
+
+  let body = source.slice(start, end);
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    if (edit.start < start || edit.end > end || edit.start > edit.end) {
+      throw new Error('Visibility edit escaped Prompt body');
+    }
+    const relativeStart = edit.start - start;
+    const relativeEnd = edit.end - start;
+    body = body.slice(0, relativeStart) + edit.replacement + body.slice(relativeEnd);
+  }
+  return body;
+}
+
+function injectInto(
+  source: string,
+  tree: MdxNode,
+): { source: string; promptCount: number } {
+  const insertions: Array<{ offset: number; value: string }> = [];
+  let promptCount = 0;
+
+  const visit = (node: MdxNode, hiddenByVisibility: boolean): void => {
+    let hidden = hiddenByVisibility;
+    if (isMdxElement(node, 'Visibility')) {
+      hidden ||= visibilityIsHidden(node);
+    }
+
+    if (isMdxElement(node, 'Prompt')) {
+      promptCount++;
+      const authored = hidden ? '' : promptBodySource(source, node);
+      insertions.push({
+        offset: openingInsertionOffset(source, node),
+        value: ` __promptSource="${encodePromptSource(authored)}"`,
+      });
+    }
+
+    node.children?.forEach((child) => visit(child, hidden));
+  };
+
+  visit(tree, false);
+
+  let transformed = source;
+  for (const insertion of insertions.sort((a, b) => b.offset - a.offset)) {
+    transformed =
+      transformed.slice(0, insertion.offset) +
+      insertion.value +
+      transformed.slice(insertion.offset);
+  }
+  return { source: transformed, promptCount };
+}
+
+export function injectPromptSources(source: string): string {
+  if (!source.includes('<Prompt')) return source;
+
+  const processor = createProcessor();
+  type ParsedMdxRoot = ReturnType<typeof processor.parse>;
+  const accept = (candidate: string, tree: ParsedMdxRoot): string => {
+    const result = injectInto(candidate, tree as MdxNode);
+    if (result.promptCount === 0) return source;
+    processor.parse(result.source);
+    return result.source;
+  };
+
+  let rawTree: ParsedMdxRoot;
+  try {
+    rawTree = processor.parse(source);
+  } catch {
+    try {
+      const repaired = applyJsxSyntaxFixes(source);
+      const repairedTree = processor.parse(repaired);
+      return accept(repaired, repairedTree);
+    } catch {
+      return source;
+    }
+  }
+
+  try {
+    return accept(source, rawTree);
+  } catch {
+    return source;
+  }
+}

package/vendored/lib/layout-helpers.tsx

@@ -2,7 +2,7 @@
 // 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 { Inter, JetBrains_Mono, Figtree } from 'next/font/google';
 import { preinit } from 'react-dom';
 import fs from 'fs';
 import path from 'path';
@@ -70,6 +70,32 @@ export const jetbrainsMono = JetBrains_Mono({
   variable: '--font-mono',
 });
 
+// Halo's face. Figtree ships as a variable font (300-900) so no `weight` array
+// is needed — the full heading ladder (600/700/800) and body weight (400) that
+// themes/halo/variables.css asks for are all covered by the single variable
+// axis. Declared with the same `--font-primary` variable as Inter: only one of
+// the two classes is ever applied to <body>, so they never collide.
+export const figtree = Figtree({
+  subsets: ['latin'],
+  display: 'swap',
+  variable: '--font-primary',
+  // DELIBERATE, and a real tradeoff — do not flip this to true without reading
+  // this through. next/font's `preload` is a static build-time flag, but the
+  // theme is only known at runtime (from docs.json), and every theme is served
+  // by the same ISR route off this shared module. So preload is necessarily
+  // all-pages-or-no-pages; it cannot be per-theme.
+  //   preload: true  -> jam/nebula/pulsar each preload a face they never render.
+  //   preload: false -> halo alone pays a brief FOUT, and `display: 'swap'`
+  //                     above already covers that; the @font-face still ships
+  //                     and loads as soon as figtree.className applies.
+  // False protects the three existing production themes at halo's expense,
+  // which is the right side to err on. Known consequence: halo pages still
+  // carry Inter's preload link (inter is declared above with preload
+  // defaulting to true) for a face they never render. That waste is not
+  // fixable while all four themes share one route — accepted, not overlooked.
+  preload: false,
+});
+
 export function getLocalFileContent(filename: string): string | null {
   try {
     const filePath = path.join(process.cwd(), 'public', filename);
@@ -303,6 +329,9 @@ export function getFontClassName(
   if (theme.name === 'nebula') {
     return `${jetbrainsMono.variable} font-mono`;
   }
+  if (theme.name === 'halo') {
+    return `${figtree.variable} ${jetbrainsMono.variable} ${figtree.className}`;
+  }
   return `${inter.variable} ${jetbrainsMono.variable} ${inter.className}`;
 }
 

package/vendored/lib/mdx-syntax-fixes.ts

@@ -0,0 +1,143 @@
+/** JSX components whose bodies commonly contain Markdown block content. */
+export const JSX_CONTENT_COMPONENTS = [
+  'Card',
+  'Columns',
+  'Note',
+  'Warning',
+  'Tip',
+  'Info',
+  'Check',
+  'Danger',
+  'Accordion',
+  'AccordionGroup',
+  'Tab',
+  'Tabs',
+  'Step',
+  'Steps',
+  'Expandable',
+  'Update',
+  'Frame',
+  'Panel',
+  'View',
+  'Varning',
+  'Avertissement',
+  'Visibility',
+  'Prompt',
+] as const;
+
+export function unindentClosingTagAfterList(content: string): string {
+  if (!/^\s+<\/[A-Z]/m.test(content)) return content;
+
+  const closingTagPattern = /^(\s+)(<\/[A-Z][\w-]*>)\s*$/;
+  const listItemPattern = /^\s*(?:[-*+]\s|\d+\.\s)/;
+  const lines = content.split('\n');
+  const out: string[] = [];
+  let lastNonBlank = '';
+
+  for (const line of lines) {
+    const closing = line.match(closingTagPattern);
+    if (closing && listItemPattern.test(lastNonBlank)) {
+      out.push(closing[2]);
+      lastNonBlank = closing[2];
+      continue;
+    }
+    out.push(line);
+    if (line.trim() !== '') lastNonBlank = line;
+  }
+
+  return out.join('\n');
+}
+
+export function unindentJsxAfterListItems(content: string): string {
+  const componentPattern = JSX_CONTENT_COMPONENTS.join('|');
+  const lines = content.split('\n');
+  const result: string[] = [];
+  let inListContext = false;
+  let jsxBlockIndent = 0;
+  let unindentingJsxBlock = false;
+  let jsxBlockDepth = 0;
+  let currentComponent = '';
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const currentIndent = line.match(/^(\s*)/)?.[1].length ?? 0;
+    const isListItem = /^[-*+]\s/.test(trimmed) || /^\d+\.\s/.test(trimmed);
+
+    if (isListItem) {
+      inListContext = true;
+      result.push(line);
+      continue;
+    }
+
+    if (!trimmed) {
+      result.push(line);
+      continue;
+    }
+
+    const openingTagMatch = trimmed.match(
+      new RegExp(`^<(${componentPattern})(?:\\s|>|$|/>)`),
+    );
+
+    if (
+      openingTagMatch &&
+      inListContext &&
+      currentIndent > 0 &&
+      !unindentingJsxBlock
+    ) {
+      unindentingJsxBlock = true;
+      jsxBlockIndent = currentIndent;
+      jsxBlockDepth = 1;
+      currentComponent = openingTagMatch[1];
+
+      if (trimmed.endsWith('/>')) {
+        unindentingJsxBlock = false;
+        jsxBlockDepth = 0;
+        inListContext = false;
+      }
+
+      const prevLine = result.length > 0 ? result[result.length - 1] : '';
+      if (prevLine.trim() !== '') result.push('');
+      result.push(trimmed);
+      continue;
+    }
+
+    if (unindentingJsxBlock) {
+      const nestedOpenMatch = trimmed.match(
+        new RegExp(`^<(${currentComponent})(?:\\s[^>]*)?>`),
+      );
+      if (nestedOpenMatch && !trimmed.endsWith('/>')) jsxBlockDepth++;
+
+      const closingTagMatch = trimmed.match(
+        new RegExp(`^</(${currentComponent})>`),
+      );
+      if (closingTagMatch) {
+        jsxBlockDepth--;
+        if (jsxBlockDepth === 0) {
+          unindentingJsxBlock = false;
+          inListContext = false;
+          currentComponent = '';
+          result.push(trimmed);
+          continue;
+        }
+      }
+
+      if (currentIndent >= jsxBlockIndent) {
+        const reducedIndent = currentIndent - jsxBlockIndent;
+        result.push(' '.repeat(reducedIndent) + trimmed);
+      } else {
+        result.push(trimmed);
+      }
+      continue;
+    }
+
+    if (currentIndent === 0) inListContext = false;
+    result.push(line);
+  }
+
+  return result.join('\n');
+}
+
+export function applyJsxSyntaxFixes(content: string): string {
+  return unindentJsxAfterListItems(unindentClosingTagAfterList(content));
+}

package/vendored/lib/mdx.ts

@@ -6,6 +6,7 @@ import rehypeShiki from '@shikijs/rehype';
 import remarkGfm from 'remark-gfm';
 import type { MDXRemoteSerializeResult } from 'next-mdx-remote';
 import { getContentDir } from './docs';
+import { injectPromptSources } from './inject-prompt-source';
 import { mdxSecurityOptions } from './mdx-security-options';
 import { remarkSvgNamespaceAttrs } from './remark-svg-namespace-attrs';
 import { getShikiOptions } from './shiki-config';
@@ -41,7 +42,7 @@ export async function getDocContent(slug: string[]): Promise<DocContent | null>
   const { data, content } = parseFrontmatterLenient(fileContents);
 
   const shikiOptions = getShikiOptions();
-  const mdxSource = await serialize(content, {
+  const mdxSource = await serialize(injectPromptSources(content), {
     // Keep expression props (e.g. cols={2}) compatible under next-mdx-remote v6.
     ...mdxSecurityOptions,
     mdxOptions: {

package/vendored/lib/normalize-config.ts

@@ -96,7 +96,7 @@ export function normalizeConfig(config: DocsConfigInput): NormalizeResult {
   // 3. Warn about layout
   if (layout) {
     warnings.push(
-      'layout field is ignored. Jamdesk determines layout from theme (pulsar=sidebar, jam/nebula=header).'
+      'layout field is ignored. Jamdesk determines layout from theme (pulsar=sidebar, jam/nebula/halo=header).'
     );
   }