jamdesk 1.1.33 → 1.1.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jamdesk",
-  "version": "1.1.33",
+  "version": "1.1.35",
   "description": "CLI for Jamdesk — build, preview, and deploy documentation sites from MDX. Dev server with hot reload, 50+ components, OpenAPI support, AI search, and Mintlify migration",
   "keywords": [
     "jamdesk",

package/vendored/app/[[...slug]]/page.tsx

@@ -41,6 +41,7 @@ import { PanelWrapper } from '@/components/mdx/PanelWrapper';
 import { ViewWrapper } from '@/components/mdx/View';
 import { getLatexRemarkPlugins, getLatexRehypePlugins } from '@/lib/latex-config';
 import { getTypographyRemarkPlugins } from '@/lib/typography-config';
+import { remarkVisibility } from '@/lib/remark-visibility';
 import { recmaCompoundComponents } from '@/lib/recma-compound-components';
 import { extractInlineComponents } from '@/lib/process-mdx-with-exports';
 import { buildEndpointFromMdx } from '@/lib/build-endpoint-from-mdx';
@@ -698,7 +699,7 @@ export default async function DocPage({ params }: PageProps) {
                   // Keep expression props (e.g. cols={2}) compatible under next-mdx-remote v6.
                   ...mdxSecurityOptions,
                   mdxOptions: {
-                    remarkPlugins: [remarkGfm, ...getTypographyRemarkPlugins(config), ...getLatexRemarkPlugins(config)],
+                    remarkPlugins: [remarkGfm, [remarkVisibility, { audience: 'humans' }], ...getTypographyRemarkPlugins(config), ...getLatexRemarkPlugins(config)],
                     rehypePlugins: [rehypeNoZoomToData, rehypeClassToClassName, rehypeCodeMeta, createShikiRehypePlugin(highlighter, config), rehypeRestoreDataTitle, ...getLatexRehypePlugins(config), rehypeSlug],
                     recmaPlugins: [recmaCompoundComponents],
                   },
@@ -724,7 +725,7 @@ export default async function DocPage({ params }: PageProps) {
         // Keep expression props (e.g. cols={2}) compatible under next-mdx-remote v6.
         ...mdxSecurityOptions,
         mdxOptions: {
-          remarkPlugins: [remarkGfm, ...getTypographyRemarkPlugins(config), ...getLatexRemarkPlugins(config)],
+          remarkPlugins: [remarkGfm, [remarkVisibility, { audience: 'humans' }], ...getTypographyRemarkPlugins(config), ...getLatexRemarkPlugins(config)],
           rehypePlugins: [rehypeNoZoomToData, rehypeClassToClassName, rehypeCodeMeta, createShikiRehypePlugin(highlighter, config), rehypeRestoreDataTitle, ...getLatexRehypePlugins(config), rehypeSlug],
           recmaPlugins: [recmaCompoundComponents],
         },

package/vendored/app/api/markdown-export/[project]/[...slug]/route.ts

@@ -0,0 +1,76 @@
+import { NextResponse } from 'next/server';
+import {
+  fetchMdxContent,
+  R2_NOT_FOUND_ERROR_NAMES,
+  R2_NOT_FOUND_MESSAGE_PREFIX,
+} from '@/lib/r2-content';
+import { filterVisibility } from '@/lib/visibility-filter';
+import { VALID_SLUG_RE } from '@/lib/middleware-helpers';
+import {
+  acceptsMarkdown,
+  MARKDOWN_CACHE_PUBLIC,
+  MARKDOWN_CACHE_PRIVATE,
+} from '@/lib/content-negotiation';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * Production `.md` export (and `Accept: text/markdown` canonical URLs).
+ * Fetches raw MDX from R2 via the existing in-memory-cached fetcher,
+ * applies the audience=agents filter, and returns as text/markdown with
+ * the same security headers the legacy /api/r2 path applied to .mdx.
+ */
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ project: string; slug: string[] }> }
+) {
+  const { project, slug } = await params;
+
+  // Defense in depth: the proxy always resolves `project` from the domain
+  // resolver before routing here, but anything reachable via direct URL
+  // must be locked to the slug character set.
+  if (!VALID_SLUG_RE.test(project)) {
+    return new NextResponse('Bad request', { status: 400 });
+  }
+
+  const pagePath = slug.join('/');
+
+  let raw: string;
+  try {
+    raw = await fetchMdxContent(project, pagePath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : '';
+    const name = err instanceof Error ? err.name : '';
+    if (
+      msg.startsWith(R2_NOT_FOUND_MESSAGE_PREFIX) ||
+      R2_NOT_FOUND_ERROR_NAMES.has(name)
+    ) {
+      return new NextResponse('Not found', { status: 404 });
+    }
+    return new NextResponse('Upstream unavailable', { status: 502 });
+  }
+
+  const filtered = filterVisibility(raw, 'agents');
+
+  // Two paths reach this handler via proxy rewrite:
+  //   (a) `.md` URL: unique CDN cache key, safe to share.
+  //   (b) canonical URL + `Accept: text/markdown`: shares a cache key with
+  //       the HTML page. Cloudflare ignores `Vary: Accept` on public entries,
+  //       so a cached markdown response would poison browser requests.
+  const cacheControl = acceptsMarkdown(request.headers.get('accept'))
+    ? MARKDOWN_CACHE_PRIVATE
+    : MARKDOWN_CACHE_PUBLIC;
+
+  return new NextResponse(filtered, {
+    headers: {
+      'Content-Type': 'text/markdown; charset=utf-8',
+      'Content-Disposition': 'inline',
+      'Cache-Control': cacheControl,
+      'Vary': 'Accept',
+      'X-Robots-Tag': 'noindex, nofollow',
+      'X-Frame-Options': 'DENY',
+      'Content-Security-Policy': "default-src 'none'",
+    },
+  });
+}

package/vendored/app/api/raw-content/[...slug]/route.ts

@@ -1,21 +1,22 @@
 import { getContentLoader } from '@/lib/content-loader';
+import { filterVisibility } from '@/lib/visibility-filter';
 import { NextResponse } from 'next/server';
 
 /**
- * Serve raw MDX content for local dev mode.
- * In production ISR mode, .md URLs are handled by middleware → R2 instead.
+ * Dev `.md` route. Applies the visibility filter with audience='agents'
+ * — strips for="humans" blocks, unwraps for="agents" blocks. Code-block-safe.
+ * Production `.md` goes through /api/markdown-export/[project]/[...slug].
  */
 export async function GET(
   _request: Request,
   { params }: { params: Promise<{ slug: string[] }> }
 ) {
   const { slug } = await params;
-  const pagePath = slug.join('/');
-
   try {
     const loader = getContentLoader();
-    const content = await loader.getContent(pagePath);
-    return new NextResponse(content, {
+    const raw = await loader.getContent(slug.join('/'));
+    const filtered = filterVisibility(raw, 'agents');
+    return new NextResponse(filtered, {
       headers: {
         'Content-Type': 'text/markdown; charset=utf-8',
         'Content-Disposition': 'inline',

package/vendored/components/mdx/MDXComponents.tsx

@@ -31,6 +31,7 @@ import { Columns } from './Columns';
 import { View, ViewProvider, ViewSelector, ViewWrapper } from './View';
 import { YouTube } from './YouTube';
 import { Video } from './Video';
+import { Visibility } from './Visibility';
 
 /**
  * Extract language from a pre element for tab label
@@ -229,6 +230,12 @@ export const MDXComponents = {
   YouTube,
   // Video player for local video files
   Video,
+  // Audience-conditional content. Filtered at MDX-compile time by
+  // lib/remark-visibility.ts for the HTML render path and by
+  // lib/visibility-filter.ts for text surfaces (.md export, llms-full.txt,
+  // search index). This React component is a fail-closed fallback for
+  // any <Visibility> that slips past both filters.
+  Visibility,
   // Sized images from preprocess-mdx (![alt](url =WIDTHx) syntax).
   // These are output as <SizedImage> JSX so they go through component mapping
   // (raw <img> JSX in MDX bypasses the components provider).

package/vendored/components/mdx/Steps.tsx

@@ -2,6 +2,7 @@
 
 import { ReactNode, Children, cloneElement, isValidElement, memo } from 'react';
 import { getIconClass } from '@/lib/icon-utils';
+import { generateSlug } from '@/lib/heading-extractor';
 
 type TitleSize = 'p' | 'h2' | 'h3';
 type IconType = 'regular' | 'solid' | 'light' | 'thin' | 'sharp-solid' | 'duotone' | 'brands';
@@ -129,9 +130,24 @@ function StepTitle({ title, titleSize }: { title: string; titleSize: TitleSize }
 
 export const Step = memo(function Step({ title, children, stepNumber, isLast, icon, iconType, titleSize = 'p' }: StepProps) {
   const containerClassName = isLast ? 'relative pb-0' : 'relative pb-8';
+  const slug = title ? generateSlug(title) || undefined : undefined;
+
+  // Emit both attrs together or neither — the DOM scanner keys off
+  // `data-step-number`, so a label without a number would be a dangling
+  // attribute, and a number without a label would produce a TOC entry with
+  // empty text.
+  const stepAttrs: { 'data-step-number'?: number; 'data-step-label'?: string } = {};
+  if (typeof stepNumber === 'number' && title) {
+    stepAttrs['data-step-number'] = stepNumber;
+    stepAttrs['data-step-label'] = title;
+  }
 
   return (
-    <div className={containerClassName}>
+    <div
+      className={containerClassName}
+      id={slug}
+      {...stepAttrs}
+    >
       {/* Vertical line connecting to next step - positioned absolutely */}
       {!isLast && (
         <div

package/vendored/components/mdx/Visibility.tsx

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+
+interface VisibilityProps {
+  for: 'humans' | 'agents';
+  children?: ReactNode;
+}
+
+/**
+ * <Visibility for="humans|agents"> — audience-conditional content.
+ *
+ * Filtering is normally done at MDX-compile time by `lib/remark-visibility.ts`
+ * (HTML render, snippets) or at the text level by `lib/visibility-filter.ts`
+ * (.md export, llms-full.txt). This React component is a defensive passthrough
+ * so if the filter ever misses (dynamic import, future MDX form, writer bug),
+ * the component still fails-closed for agents and fails-visible for humans.
+ */
+export function Visibility({ for: audience, children }: VisibilityProps) {
+  if (audience === 'agents') return null;
+  return <>{children}</>;
+}

package/vendored/components/navigation/TableOfContents.tsx

@@ -2,12 +2,13 @@
 
 import { useEffect, useState, useRef, useCallback } from 'react';
 import { getIconClass } from '@/lib/icon-utils';
-import { generateSlug } from '@/lib/heading-extractor';
+import { extractHeadings } from '@/lib/heading-extractor';
 
 interface TocItem {
   id: string;
   text: string;
   level: number;
+  stepNumber?: number;
 }
 
 interface TableOfContentsProps {
@@ -196,75 +197,128 @@ export function TableOfContents({ content, className = '' }: TableOfContentsProp
     return () => observer.disconnect();
   }, [updateThumb]);
 
-  // Parse headings from content in source order, then scan DOM for dynamic components
+  // Source-order parse gives immediate headings; the MutationObserver below
+  // keeps the list in sync when dynamic components (Accordion, Tabs) reveal
+  // Steps after initial render.
   useEffect(() => {
-    // Line-by-line pass to preserve source order and skip fenced code blocks
-    const items: TocItem[] = [];
-    const lines = content.split('\n');
-    let inCodeBlock = false;
-    let fencePattern = '';
-
-    for (const line of lines) {
-      const fenceMatch = line.match(/^(`{3,}|~{3,})/);
-      if (fenceMatch) {
-        if (!inCodeBlock) {
-          inCodeBlock = true;
-          fencePattern = fenceMatch[1];
-          continue;
-        } else if (line.startsWith(fencePattern)) {
-          inCodeBlock = false;
-          fencePattern = '';
-          continue;
-        }
-      }
-      if (inCodeBlock) continue;
-
-      const headingMatch = line.match(/^(#{2,3})\s+(.+)$/);
-      if (headingMatch) {
-        const level = headingMatch[1].length;
-        const text = headingMatch[2].trim();
-        const id = generateSlug(text);
-        if (id) items.push({ id, text, level });
-      }
+    const sourceItems: TocItem[] = extractHeadings(content)
+      .filter(h => h.level === 2 || h.level === 3)
+      .map(h => ({
+        id: h.id,
+        text: h.text,
+        level: h.level,
+        stepNumber: h.stepNumber,
+      }));
 
-      const updateMatch = line.match(/<Update\s+label=["']([^"']+)["']/);
-      if (updateMatch) {
-        const text = updateMatch[1];
-        const id = generateSlug(text);
-        if (id) items.push({ id, text, level: 2 });
-      }
-    }
-
-    setHeadings(items);
+    setHeadings(sourceItems);
 
-    // DOM scan: single query to get all TOC elements in document order
     const scanDomHeadings = () => {
-      const tocElements = document.querySelectorAll('main h2[id], main h3[id], main [data-update-label]');
+      const tocElements = document.querySelectorAll<HTMLElement>(
+        'main h2[id], main h3[id], main [data-update-label], main [data-step-number]',
+      );
       const newItems: TocItem[] = [];
       const seenDomIds = new Set<string>();
+      const collisions: string[] = [];
 
       tocElements.forEach((element) => {
         const id = element.id;
-        if (!id || seenDomIds.has(id)) return;
+        if (!id) return;
+        if (seenDomIds.has(id)) {
+          collisions.push(id);
+          return;
+        }
+
+        const stepNumberAttr = element.getAttribute('data-step-number');
+        const isStep = stepNumberAttr !== null && stepNumberAttr !== '';
+        const isUpdate = !isStep && element.hasAttribute('data-update-label');
+
+        let text = '';
+        let level = 2;
+        let stepNumber: number | undefined;
+
+        if (isStep) {
+          text = element.getAttribute('data-step-label')?.trim() || '';
+          level = 3;
+          const parsed = parseInt(stepNumberAttr as string, 10);
+          stepNumber = Number.isFinite(parsed) ? parsed : undefined;
+        } else if (isUpdate) {
+          text = element.getAttribute('data-update-label')?.trim() || '';
+          level = 2;
+        } else {
+          text = element.textContent?.trim() || '';
+          level = element.tagName === 'H2' ? 2 : 3;
+        }
 
-        const isUpdate = element.hasAttribute('data-update-label');
-        const text = isUpdate
-          ? (element.getAttribute('data-update-label') || '')
-          : (element.textContent?.trim() || '');
         if (!text) return;
 
         seenDomIds.add(id);
-        const level = isUpdate ? 2 : (element.tagName === 'H2' ? 2 : 3);
-        newItems.push({ id, text, level });
+        newItems.push({ id, text, level, stepNumber });
       });
 
-      if (newItems.length > 0) {
-        setHeadings(newItems);
+      // Dev-mode warning for slug collisions. In production builds, stay
+      // silent — browsers still render correctly (first match wins).
+      if (collisions.length > 0 && process.env.NODE_ENV !== 'production') {
+        console.warn(
+          `[TableOfContents] Duplicate anchor id(s) detected on this page: ${[...new Set(collisions)].join(', ')}. ` +
+          `This usually means a <Step title="X"> collides with a heading of the same text. ` +
+          `Only the first element will be targetable via fragment link or TOC click.`,
+        );
       }
+
+      if (newItems.length === 0) return;
+
+      // Dedupe re-renders: if the new item list matches the current one
+      // position-for-position on (id, stepNumber), skip setState. This keeps
+      // the MutationObserver cheap when it fires on unrelated DOM changes.
+      setHeadings(prev => {
+        if (prev.length !== newItems.length) return newItems;
+        for (let i = 0; i < newItems.length; i++) {
+          if (
+            prev[i].id !== newItems[i].id ||
+            prev[i].stepNumber !== newItems[i].stepNumber ||
+            prev[i].text !== newItems[i].text
+          ) {
+            return newItems;
+          }
+        }
+        return prev;
+      });
     };
 
-    const timer = setTimeout(scanDomHeadings, 500);
-    return () => clearTimeout(timer);
+    // Coalesce scans to one per animation frame. cancelAnimationFrame in the
+    // cleanup below is only effective while scheduledScan is non-null — once
+    // the rAF callback starts, the functional setHeadings is safe on an
+    // unmounted tree because it returns prev when items are unchanged.
+    let scheduledScan: number | null = null;
+    const scheduleScan = () => {
+      if (scheduledScan !== null) return;
+      scheduledScan = requestAnimationFrame(() => {
+        scheduledScan = null;
+        scanDomHeadings();
+      });
+    };
+
+    scheduleScan();
+
+    const mainEl = document.querySelector('main');
+    const observer = mainEl ? new MutationObserver(scheduleScan) : null;
+    if (mainEl && observer) {
+      observer.observe(mainEl, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: ['id', 'data-step-number', 'data-step-label', 'data-update-label'],
+      });
+    } else if (!mainEl && process.env.NODE_ENV !== 'production') {
+      console.warn(
+        '[TableOfContents] no <main> element found — late-mount TOC updates will not be observed.',
+      );
+    }
+
+    return () => {
+      if (scheduledScan !== null) cancelAnimationFrame(scheduledScan);
+      observer?.disconnect();
+    };
   }, [content]);
 
   // For API pages, hide TOC if there are code panels visible
@@ -415,6 +469,7 @@ export function TableOfContents({ content, className = '' }: TableOfContentsProp
         <div ref={containerRef} className="relative flex flex-col">
           {headings.map((heading, index) => {
             const isActive = activeAnchors.includes(heading.id);
+            const hasStepNumber = typeof heading.stepNumber === 'number';
 
             const handleClick = (e: React.MouseEvent<HTMLAnchorElement>) => {
               e.preventDefault();
@@ -425,18 +480,45 @@ export function TableOfContents({ content, className = '' }: TableOfContentsProp
               }
             };
 
+            // 30px leaves room for the absolute-positioned 18px step circle
+            // (insetInlineStart: 1) + a gap. Non-step H3s use the same value
+            // so mixed step/non-step groups align visually.
+            const startOffset = heading.level === 3
+              ? 30
+              : getItemOffset(heading.level);
+
             return (
               <a
                 key={`${heading.id}-${index}`}
                 href={`#${heading.id}`}
                 onClick={handleClick}
                 data-active={isActive}
+                data-step={hasStepNumber || undefined}
                 className={`
                   relative block py-1.5 text-sm transition-colors duration-200
                   ${getLinkClass(heading.level, isActive)}
                 `}
-                style={{ paddingInlineStart: getItemOffset(heading.level) }}
+                style={{ paddingInlineStart: startOffset }}
               >
+                {hasStepNumber && (
+                  <span
+                    aria-hidden="true"
+                    className="absolute flex items-center justify-center rounded-full text-[11px] font-medium"
+                    style={{
+                      insetInlineStart: 1,
+                      top: '50%',
+                      transform: 'translateY(-50%)',
+                      width: 18,
+                      height: 18,
+                      backgroundColor: isActive
+                        ? 'var(--color-primary)'
+                        : 'var(--color-bg-primary)',
+                      color: isActive ? '#fff' : 'var(--color-text-muted)',
+                    }}
+                  >
+                    {heading.stepNumber}
+                  </span>
+                )}
                 {heading.text}
               </a>
             );

package/vendored/lib/content-negotiation.ts

@@ -0,0 +1,29 @@
+/**
+ * True if the Accept header contains a `text/markdown` offer with a
+ * non-zero q-value (or no q-value). Scans offers individually so
+ * `text/markdown;q=0` ("explicitly not markdown") doesn't trigger a match.
+ *
+ * Shared between the proxy (for URL rewriting) and the markdown-export
+ * route handler (for cache policy decisions) so both layers agree on
+ * what counts as an agent-facing request.
+ */
+export function acceptsMarkdown(accept: string | null | undefined): boolean {
+  if (!accept) return false;
+  // Browsers never send text/markdown; short-circuit on the ~99% hot path
+  // without allocating a lowercased copy or splitting into offers.
+  if (accept.search(/text\/markdown/i) === -1) return false;
+  return accept
+    .toLowerCase()
+    .split(',')
+    .some(offer => {
+      const [type, ...params] = offer.trim().split(';').map(s => s.trim());
+      if (type !== 'text/markdown') return false;
+      const qParam = params.find(p => p.startsWith('q='));
+      if (!qParam) return true;
+      const q = Number.parseFloat(qParam.slice(2));
+      return Number.isFinite(q) && q > 0;
+    });
+}
+
+export const MARKDOWN_CACHE_PUBLIC = 'public, max-age=3600, s-maxage=86400';
+export const MARKDOWN_CACHE_PRIVATE = 'private, no-store';

package/vendored/lib/heading-extractor.ts

@@ -2,7 +2,8 @@
  * Heading extractor for link validation.
  * Extracts heading slugs from MDX content to validate #fragment links.
  *
- * Canonical source for generateSlug — imported by TableOfContents.tsx and Update.tsx.
+ * Canonical source for generateSlug — imported by TableOfContents.tsx, Update.tsx,
+ * and Steps.tsx.
  */
 
 export interface HeadingInfo {
@@ -10,6 +11,8 @@ export interface HeadingInfo {
   text: string;
   level: number;
   line: number; // 1-indexed
+  /** When the entry is a <Step> inside a <Steps> block, this is its 1-based index within the block. */
+  stepNumber?: number;
 }
 
 /**
@@ -26,10 +29,20 @@ export function generateSlug(text: string): string {
 const HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
 const FENCE_REGEX = /^(`{3,}|~{3,})/;
 const UPDATE_LABEL_REGEX = /<Update\s+label=["']([^"']+)["']/;
+const STEPS_OPEN_REGEX = /<Steps(\s|>)/;
+const STEPS_CLOSE_REGEX = /<\/Steps>/;
+// Global flag — we iterate with matchAll so authors who inline multiple
+// <Step> tags on one line get every one numbered.
+// Alternation (not a character class) keeps the capture from terminating on
+// apostrophes inside double-quoted attribute values (e.g. `<Step title="You're Live">`).
+// MUST only be used with matchAll — direct `test`/`exec` would share
+// lastIndex across calls and miscount.
+const STEP_TITLE_REGEX = /<Step\s+[^>]*title=(?:"([^"]+)"|'([^']+)')/g;
 
 /**
  * Extract all heading slugs from MDX content.
- * Includes markdown headings and <Update label="..."> component anchors.
+ * Includes markdown headings, <Update label="..."> component anchors,
+ * and <Step title="..."> entries inside <Steps> blocks (with per-block numbering).
  * Skips content inside fenced code blocks.
  */
 export function extractHeadings(content: string): HeadingInfo[] {
@@ -37,6 +50,10 @@ export function extractHeadings(content: string): HeadingInfo[] {
   const lines = content.split('\n');
   let inCodeBlock = false;
   let fencePattern = '';
+  // Boolean (not depth counter) — resets on every <Steps> open so an unclosed
+  // block can't stick the counter across subsequent blocks.
+  let inStepsBlock = false;
+  let stepCounter = 0;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -56,6 +73,14 @@ export function extractHeadings(content: string): HeadingInfo[] {
 
     if (inCodeBlock) continue;
 
+    // <Steps> open resets the per-block counter unconditionally. Ordering
+    // matters: open-reset must run BEFORE step matching on the same line so
+    // `<Steps><Step title="A">...</Step>` numbers "A" as 1.
+    if (STEPS_OPEN_REGEX.test(line)) {
+      inStepsBlock = true;
+      stepCounter = 0;
+    }
+
     const headingMatch = line.match(HEADING_REGEX);
     if (headingMatch) {
       const level = headingMatch[1].length;
@@ -74,6 +99,28 @@ export function extractHeadings(content: string): HeadingInfo[] {
         headings.push({ id, text, level: 2, line: i + 1 });
       }
     }
+
+    if (inStepsBlock) {
+      for (const match of line.matchAll(STEP_TITLE_REGEX)) {
+        const text = match[1] ?? match[2];
+        const id = generateSlug(text);
+        if (!id) continue;
+        stepCounter += 1;
+        headings.push({
+          id,
+          text,
+          level: 3,
+          line: i + 1,
+          stepNumber: stepCounter,
+        });
+      }
+    }
+
+    // </Steps> close runs AFTER step matching so `</Steps>` on the same line
+    // as the last <Step> still picks up that step.
+    if (STEPS_CLOSE_REGEX.test(line)) {
+      inStepsBlock = false;
+    }
   }
 
   return headings;

package/vendored/lib/preprocess-mdx.ts

@@ -8,6 +8,7 @@
 
 import { ASSET_PREFIX, appendAssetVersion } from './docs-types';
 import { checkForDeprecatedComponents } from './deprecated-components';
+import { filterVisibility } from './visibility-filter';
 
 /**
  * JSX components that contain markdown content requiring special preprocessing.
@@ -35,6 +36,7 @@ const JSX_CONTENT_COMPONENTS = [
   'View',
   'Varning',
   'Avertissement',
+  'Visibility',
 ] as const;
 
 /**
@@ -935,6 +937,11 @@ export function preprocessMdx(content: string, options?: { assetVersion?: string
   let processed = content;
   const assetVersion = options?.assetVersion;
 
+  // Audience filter (code-block-safe). The remark plugin in page.tsx is the
+  // primary line of defense for HTML render; this backs up snippet files
+  // that flow through preprocessMdx independently.
+  processed = filterVisibility(processed, 'humans');
+
   // Strip snippet imports
   processed = stripSnippetImports(processed);
 

package/vendored/lib/process-mdx-with-exports.ts

@@ -12,6 +12,7 @@ import remarkParse from 'remark-parse';
 import remarkMdx from 'remark-mdx';
 import { VFile } from 'vfile';
 import { remarkExtractExports } from './remark-extract-exports';
+import { remarkVisibility } from './remark-visibility';
 import { compileInlineComponents } from './mdx-inline-components';
 import { remarkExtractParamFields } from './remark-extract-param-fields';
 import type { ExtractedParam } from './remark-extract-param-fields';
@@ -30,6 +31,7 @@ interface ProcessResult {
 const mdxProcessor = unified()
   .use(remarkParse)
   .use(remarkMdx)
+  .use(remarkVisibility, { audience: 'humans' })
   .use(remarkExtractExports)
   .use(remarkExtractParamFields);
 

package/vendored/lib/r2-content.ts

@@ -9,6 +9,12 @@ import type { DocsConfig } from './docs-types';
 
 export type { DocsConfig };
 
+export const R2_NOT_FOUND_ERROR_NAMES: ReadonlySet<string> = new Set([
+  'NoSuchKey',
+  'AccessDenied',
+]);
+export const R2_NOT_FOUND_MESSAGE_PREFIX = 'Page not found';
+
 export function evictOldest<K, V>(cache: Map<K, V>, maxSize: number): void {
   if (cache.size <= maxSize) return;
   const toDelete = cache.size - maxSize;

package/vendored/lib/remark-visibility.ts

@@ -0,0 +1,86 @@
+/**
+ * remark-visibility
+ *
+ * MDX AST plugin that strips or unwraps <Visibility for="humans|agents">
+ * elements based on the consuming audience. Run this plugin BEFORE
+ * remarkExtractExports so exports inside filtered-out blocks are
+ * dropped along with the block.
+ *
+ * Unlike the text-level filter in lib/visibility-filter.ts, this plugin
+ * is safe for:
+ *   - code blocks (mdast `code` nodes aren't traversed as JSX)
+ *   - nested <Visibility> elements
+ *   - JSX expressions
+ */
+
+import type { Root, RootContent } from 'mdast';
+import type { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx';
+
+type JsxEl = MdxJsxFlowElement | MdxJsxTextElement;
+
+export interface RemarkVisibilityOptions {
+  audience: 'humans' | 'agents';
+}
+
+function isVisibility(node: unknown): node is JsxEl {
+  if (!node || typeof node !== 'object') return false;
+  const n = node as { type?: string; name?: string };
+  return (
+    (n.type === 'mdxJsxFlowElement' || n.type === 'mdxJsxTextElement') &&
+    n.name === 'Visibility'
+  );
+}
+
+function getForAttr(node: JsxEl): string | null {
+  for (const attr of node.attributes ?? []) {
+    if (attr.type === 'mdxJsxAttribute' && attr.name === 'for') {
+      if (typeof attr.value === 'string') return attr.value.toLowerCase();
+      // Expression-valued attribute — treat as unknown, leave alone.
+      return null;
+    }
+  }
+  return null;
+}
+
+export function remarkVisibility(options: RemarkVisibilityOptions) {
+  const { audience } = options;
+  return function transform(tree: Root): void {
+    visitInPlace(tree, audience);
+  };
+}
+
+function visitInPlace(
+  parent: { children?: RootContent[] },
+  audience: 'humans' | 'agents',
+): void {
+  if (!Array.isArray(parent.children)) return;
+
+  const next: RootContent[] = [];
+  for (const child of parent.children) {
+    if (isVisibility(child)) {
+      const target = getForAttr(child);
+      if (target === null) {
+        visitInPlace(child as unknown as { children?: RootContent[] }, audience);
+        next.push(child);
+        continue;
+      }
+      if (target !== 'humans' && target !== 'agents') {
+        visitInPlace(child as unknown as { children?: RootContent[] }, audience);
+        next.push(child);
+        continue;
+      }
+      if (target === audience) {
+        // Unwrap: recurse first so nested <Visibility> get filtered, then splice in children.
+        visitInPlace(child as unknown as { children?: RootContent[] }, audience);
+        next.push(...((child.children ?? []) as RootContent[]));
+      }
+      // Else: drop entirely.
+      continue;
+    }
+
+    visitInPlace(child as unknown as { children?: RootContent[] }, audience);
+    next.push(child);
+  }
+
+  parent.children = next;
+}

package/vendored/lib/search.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { parseFrontmatterLenient } from './frontmatter-utils';
+import { filterVisibility } from './visibility-filter';
 
 export interface SearchResult {
   id: string;
@@ -79,8 +80,9 @@ export function buildSearchIndex(): SearchResult[] {
         const fileContents = fs.readFileSync(filePath, 'utf8');
         const { data, content } = parseFrontmatterLenient(fileContents);
 
-        // Extract sections from content
-        const sections = extractSections(content);
+        // Filter for="agents" content out of the search index.
+        const visibleContent = filterVisibility(content, 'humans');
+        const sections = extractSections(visibleContent);
 
         sections.forEach((section, idx) => {
           const cleanContent = stripMarkdown(section.content);

package/vendored/lib/snippet-loader-isr.ts

@@ -14,6 +14,7 @@ import * as jsxRuntime from 'react/jsx-runtime';
 import { transform } from '@babel/standalone';
 import { fetchSnippet } from './r2-content';
 import { extractSnippetImports } from './preprocess-mdx';
+import { filterVisibility } from './visibility-filter';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AnyComponent = React.ComponentType<any>;
@@ -240,8 +241,10 @@ async function compileSnippet(
     return cached.result;
   }
 
-  // Fetch from R2
-  const source = await fetchSnippet(projectSlug, snippetPath);
+  // Fetch from R2 and strip <Visibility for="agents"> blocks before compiling.
+  // Filter before caching so cached components are already audience-filtered.
+  const rawSource = await fetchSnippet(projectSlug, snippetPath);
+  const source = filterVisibility(rawSource, 'humans');
 
   // Check for 'use client' directive
   const trimmed = source.trimStart();

package/vendored/lib/static-artifacts.ts

@@ -7,6 +7,7 @@
 
 import type { NavigationConfig } from './docs-types.js';
 import { RECURSE_KEYS } from './enhance-navigation.js';
+import { filterVisibility } from './visibility-filter.js';
 
 /**
  * Page metadata for artifact generation.
@@ -313,7 +314,7 @@ export function generateLlmsFullTxt(options: LlmsFullTxtOptions): string {
       parts.push(`*${page.frontmatter.description}*\n\n`);
     }
 
-    const content = page.content.trim();
+    const content = filterVisibility(page.content, 'agents').trim();
     if (content) {
       parts.push(`${content}\n\n`);
     }
@@ -676,7 +677,11 @@ export function generateSearchData(pages: SearchPageInfo[]): string {
     const pathWithoutExt = page.path.replace(/\.mdx?$/, '');
     const slug = pathWithoutExt.replace(/\\/g, '/');
     const pageType = inferPageType(slug);
-    const sections = extractSections(page.content);
+    // Filter for="agents" content out of the search index — the site
+    // search is a human-facing surface, so agent-only content must not
+    // leak into autocomplete.
+    const visibleContent = filterVisibility(page.content, 'humans');
+    const sections = extractSections(visibleContent);
 
     sections.forEach((section, idx) => {
       const cleanContent = stripMarkdown(section.content);

package/vendored/lib/visibility-filter.ts

@@ -0,0 +1,162 @@
+/**
+ * Visibility text-level filter — used by the prod `.md` export route, the
+ * search-index generator, and the CJS build scripts, which can't run the
+ * MDX AST pipeline.
+ *
+ * For HTML render and snippets, the remark plugin at `lib/remark-visibility.ts`
+ * is used instead (AST-safe; handles nested tags and JSX expressions).
+ *
+ * This filter preserves:
+ *   - Fenced code blocks (``` and ~~~), with or without trailing whitespace
+ *     after the closer
+ *   - CommonMark indented code blocks (4+ spaces or tab, preceded by a
+ *     blank line or start-of-string)
+ *   - Inline code (`...`)
+ *
+ * KNOWN LIMITATION: this filter is not nesting-safe. A non-greedy regex
+ * always consumes to the first </Visibility>. The fixpoint loop handles
+ * sibling blocks produced by unwrap, but nested <Visibility> in the text
+ * surface (.md export, llms-full.txt) produces mangled output. Customer
+ * docs discourage nesting. For the HTML render surface the remark plugin
+ * handles nesting correctly.
+ */
+
+export type VisibilityAudience = 'humans' | 'agents';
+
+// Attribute region tolerates `>` inside quoted values (writer-legal MDX
+// like `<Visibility title="a>b">`). We alternate quoted strings vs
+// non-special chars so `>` in a quoted value can't prematurely close the
+// tag. Pattern: `"..."`, `'...'`, or a char that's not `>`/`"`/`'`.
+const VISIBILITY_TAG =
+  /<Visibility\s+((?:"[^"]*"|'[^']*'|[^>"'])*?)(?:\/>|>([\s\S]*?)<\/Visibility>)/g;
+// Anchor `for` on whitespace / start-of-attrs so attributes like
+// `data-for="x"` or `my-for="x"` can't collide.
+const FOR_ATTR = /(?:^|\s)for\s*=\s*["']([^"']+)["']/;
+
+// Closing fence tolerates trailing whitespace (CommonMark §4.5).
+const FENCED_BLOCK = /(^|\n)(```|~~~)[^\n]*\n[\s\S]*?\n\2[ \t]*(?=\n|$)/g;
+const INLINE_CODE = /`[^`\n]+`/g;
+const INDENTED_LINE = /^(?: {4,}|\t)/;
+// Cheap pre-check: indented code blocks require a \n followed by 4+ spaces
+// or a tab. If neither appears, skip the line-split + per-line scan below.
+const INDENT_PRECHECK = /\n(?: {4}|\t)/;
+
+// Fixpoint-loop cap. Depth of re-matches in any real document is <<10;
+// this guards against pathological / adversarial input.
+const MAX_PASSES = 16;
+
+// CommonMark indented code blocks (4+ spaces or a tab, preceded by a blank
+// line or start-of-string). Returns half-open offset ranges. Trailing blank
+// lines inside a block are excluded from the preserved range.
+function findIndentedCodeRanges(content: string): Array<[number, number]> {
+  if (!INDENT_PRECHECK.test(content) && !INDENTED_LINE.test(content)) {
+    return [];
+  }
+  const ranges: Array<[number, number]> = [];
+  const lines = content.split('\n');
+  const offsets: number[] = new Array(lines.length + 1);
+  offsets[0] = 0;
+  for (let i = 0; i < lines.length; i++) {
+    offsets[i + 1] = offsets[i] + lines[i].length + 1;
+  }
+
+  let blockStart = -1;
+  let trailingBlanks = 0;
+  let prevBlank = true; // start-of-string qualifies as "blank" for trigger
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isBlank = line.trim() === '';
+    const isIndented = INDENTED_LINE.test(line);
+    if (blockStart < 0) {
+      if (prevBlank && isIndented && !isBlank) {
+        blockStart = i;
+        trailingBlanks = 0;
+      }
+    } else if (isIndented && !isBlank) {
+      trailingBlanks = 0;
+    } else if (isBlank) {
+      trailingBlanks++;
+    } else {
+      ranges.push([offsets[blockStart], offsets[i - trailingBlanks]]);
+      blockStart = -1;
+      trailingBlanks = 0;
+    }
+    prevBlank = isBlank;
+  }
+  if (blockStart >= 0) {
+    const end = lines.length - trailingBlanks;
+    ranges.push([offsets[blockStart], offsets[end]]);
+  }
+  return ranges;
+}
+
+function transformInlineAware(content: string, fn: (text: string) => string): string {
+  const out: string[] = [];
+  let last = 0;
+  for (const m of content.matchAll(INLINE_CODE)) {
+    const idx = m.index ?? 0;
+    out.push(fn(content.slice(last, idx)));
+    out.push(m[0]);
+    last = idx + m[0].length;
+  }
+  out.push(fn(content.slice(last)));
+  return out.join('');
+}
+
+function transformOutsideIndentedCode(content: string, fn: (text: string) => string): string {
+  const ranges = findIndentedCodeRanges(content);
+  if (ranges.length === 0) return transformInlineAware(content, fn);
+  const parts: string[] = [];
+  let last = 0;
+  for (const [start, end] of ranges) {
+    parts.push(transformInlineAware(content.slice(last, start), fn));
+    parts.push(content.slice(start, end));
+    last = end;
+  }
+  parts.push(transformInlineAware(content.slice(last), fn));
+  return parts.join('');
+}
+
+// Apply a transform only to regions OUTSIDE fenced, indented, and inline code.
+function transformOutsideCodeBlocks(
+  content: string,
+  fn: (text: string) => string,
+): string {
+  const parts: string[] = [];
+  let last = 0;
+  for (const m of content.matchAll(FENCED_BLOCK)) {
+    const idx = m.index ?? 0;
+    parts.push(transformOutsideIndentedCode(content.slice(last, idx), fn));
+    parts.push(m[0]);
+    last = idx + m[0].length;
+  }
+  parts.push(transformOutsideIndentedCode(content.slice(last), fn));
+  return parts.join('');
+}
+
+function filterVisibilityRaw(content: string, audience: VisibilityAudience): string {
+  return content.replace(VISIBILITY_TAG, (match, attrs: string, inner: string | undefined) => {
+    const forMatch = attrs.match(FOR_ATTR);
+    if (!forMatch) return match;
+    const target = forMatch[1].toLowerCase();
+    if (target !== 'humans' && target !== 'agents') return match;
+    if (target === audience) return inner ?? '';
+    return '';
+  });
+}
+
+/**
+ * Filter <Visibility> blocks from MDX text. Safe for fenced, indented, and
+ * inline code. Iterates to a fixpoint so unwrap passes surface newly-
+ * adjacent tags.
+ */
+export function filterVisibility(content: string, audience: VisibilityAudience): string {
+  let prev: string;
+  let out = content;
+  for (let i = 0; i < MAX_PASSES; i++) {
+    prev = out;
+    out = transformOutsideCodeBlocks(prev, t => filterVisibilityRaw(t, audience));
+    if (out === prev) break;
+  }
+  return out;
+}

package/vendored/scripts/build-search-index.cjs

@@ -23,6 +23,7 @@ const matter = require('gray-matter');
 const os = require('os');
 const { create, insertMultiple } = require('@orama/orama');
 const { persist } = require('@orama/plugin-data-persistence');
+const { filterVisibility } = require('./visibility-filter.cjs');
 
 // Concurrency control for parallel file processing
 const CONCURRENCY = parseInt(process.env.SEARCH_INDEX_CONCURRENCY || '') || os.cpus().length * 2;
@@ -256,7 +257,9 @@ async function buildSearchIndex() {
     try {
       const fileContents = await fsPromises.readFile(filePath, 'utf8');
       const { data, content } = parseFrontmatterLenient(fileContents);
-      const sections = extractSections(content);
+      // Filter for="agents" content out of the search index.
+      const visibleContent = filterVisibility(content, 'humans');
+      const sections = extractSections(visibleContent);
 
       const docs = [];
       const normalizedSlug = slug.replace(/\\/g, '/');

package/vendored/scripts/validate-links.cjs

@@ -219,16 +219,26 @@ function generateSlug(text) {
 
 /**
  * Extract heading slugs from MDX content.
- * Includes markdown headings and <Update label="..."> component anchors.
+ * Includes markdown headings, <Update label="..."> anchors, and
+ * <Step title="..."> anchors inside a <Steps> block.
  * Skips content inside fenced code blocks.
  *
- * Uses single-pass fence tracking (matches heading-extractor.ts pattern).
+ * Must stay semantically compatible with extractHeadings() in lib/heading-extractor.ts
+ * for slug collection. stepNumber tracking is intentionally omitted here — this
+ * function returns a Set<string>, not HeadingInfo[].
  */
 function extractHeadingSlugs(content) {
   const slugs = new Set();
   const lines = content.split('\n');
   let inCodeBlock = false;
   let fencePattern = '';
+  let inStepsBlock = false;
+
+  const STEPS_OPEN_REGEX = /<Steps(\s|>)/;
+  const STEPS_CLOSE_REGEX = /<\/Steps>/;
+  // Alternation, not a character class — must not terminate at apostrophes
+  // inside double-quoted attribute values (e.g. <Step title="You're Live">).
+  const STEP_TITLE_REGEX = /<Step\s+[^>]*title=(?:"([^"]+)"|'([^']+)')/g;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -248,6 +258,10 @@ function extractHeadingSlugs(content) {
 
     if (inCodeBlock) continue;
 
+    if (STEPS_OPEN_REGEX.test(line)) {
+      inStepsBlock = true;
+    }
+
     const headingMatch = line.match(/^#{1,6}\s+(.+)$/);
     if (headingMatch) {
       const slug = generateSlug(headingMatch[1].trim());
@@ -259,6 +273,17 @@ function extractHeadingSlugs(content) {
       const slug = generateSlug(updateMatch[1]);
       if (slug) slugs.add(slug);
     }
+
+    if (inStepsBlock) {
+      for (const match of line.matchAll(STEP_TITLE_REGEX)) {
+        const slug = generateSlug(match[1] ?? match[2]);
+        if (slug) slugs.add(slug);
+      }
+    }
+
+    if (STEPS_CLOSE_REGEX.test(line)) {
+      inStepsBlock = false;
+    }
   }
 
   return slugs;

package/vendored/scripts/visibility-filter.cjs

@@ -0,0 +1,125 @@
+/**
+ * CJS mirror of lib/visibility-filter.ts.
+ *
+ * Used by CJS build scripts (generate-llms-full.cjs, build-search-index.cjs)
+ * that can't import the ESM TypeScript source. Behavior must stay
+ * byte-for-byte identical to the TS filter so that runtime and build-time
+ * outputs match (see `__tests__/lib/visibility-filter.test.ts` for the
+ * behaviors we pin).
+ */
+
+'use strict';
+
+const VIS_TAG =
+  /<Visibility\s+((?:"[^"]*"|'[^']*'|[^>"'])*?)(?:\/>|>([\s\S]*?)<\/Visibility>)/g;
+const VIS_FOR = /(?:^|\s)for\s*=\s*["']([^"']+)["']/;
+const VIS_FENCED = /(^|\n)(```|~~~)[^\n]*\n[\s\S]*?\n\2[ \t]*(?=\n|$)/g;
+const VIS_INLINE = /`[^`\n]+`/g;
+const VIS_INDENTED_LINE = /^(?: {4,}|\t)/;
+const VIS_INDENT_PRECHECK = /\n(?: {4}|\t)/;
+const VIS_MAX_PASSES = 16;
+
+function findIndentedCodeRanges(content) {
+  if (!VIS_INDENT_PRECHECK.test(content) && !VIS_INDENTED_LINE.test(content)) {
+    return [];
+  }
+  const ranges = [];
+  const lines = content.split('\n');
+  const offsets = new Array(lines.length + 1);
+  offsets[0] = 0;
+  for (let i = 0; i < lines.length; i++) {
+    offsets[i + 1] = offsets[i] + lines[i].length + 1;
+  }
+
+  let blockStart = -1;
+  let trailingBlanks = 0;
+  let prevBlank = true;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isBlank = line.trim() === '';
+    const isIndented = VIS_INDENTED_LINE.test(line);
+    if (blockStart < 0) {
+      if (prevBlank && isIndented && !isBlank) {
+        blockStart = i;
+        trailingBlanks = 0;
+      }
+    } else if (isIndented && !isBlank) {
+      trailingBlanks = 0;
+    } else if (isBlank) {
+      trailingBlanks++;
+    } else {
+      ranges.push([offsets[blockStart], offsets[i - trailingBlanks]]);
+      blockStart = -1;
+      trailingBlanks = 0;
+    }
+    prevBlank = isBlank;
+  }
+  if (blockStart >= 0) {
+    const end = lines.length - trailingBlanks;
+    ranges.push([offsets[blockStart], offsets[end]]);
+  }
+  return ranges;
+}
+
+function filterVisibilityRaw(content, audience) {
+  return content.replace(VIS_TAG, (match, attrs, inner) => {
+    const m = attrs.match(VIS_FOR);
+    if (!m) return match;
+    const t = m[1].toLowerCase();
+    if (t !== 'humans' && t !== 'agents') return match;
+    if (t === audience) return inner == null ? '' : inner;
+    return '';
+  });
+}
+
+function transformInlineAware(content, fn) {
+  const out = [];
+  let last = 0;
+  for (const m of content.matchAll(VIS_INLINE)) {
+    const idx = m.index ?? 0;
+    out.push(fn(content.slice(last, idx)));
+    out.push(m[0]);
+    last = idx + m[0].length;
+  }
+  out.push(fn(content.slice(last)));
+  return out.join('');
+}
+
+function transformOutsideIndentedCode(content, fn) {
+  const ranges = findIndentedCodeRanges(content);
+  if (ranges.length === 0) return transformInlineAware(content, fn);
+  const parts = [];
+  let last = 0;
+  for (const [start, end] of ranges) {
+    parts.push(transformInlineAware(content.slice(last, start), fn));
+    parts.push(content.slice(start, end));
+    last = end;
+  }
+  parts.push(transformInlineAware(content.slice(last), fn));
+  return parts.join('');
+}
+
+function filterVisibilityOnce(content, audience) {
+  const parts = [];
+  let last = 0;
+  for (const m of content.matchAll(VIS_FENCED)) {
+    const idx = m.index ?? 0;
+    parts.push(transformOutsideIndentedCode(content.slice(last, idx), t => filterVisibilityRaw(t, audience)));
+    parts.push(m[0]);
+    last = idx + m[0].length;
+  }
+  parts.push(transformOutsideIndentedCode(content.slice(last), t => filterVisibilityRaw(t, audience)));
+  return parts.join('');
+}
+
+function filterVisibility(content, audience) {
+  let out = content;
+  for (let i = 0; i < VIS_MAX_PASSES; i++) {
+    const prev = out;
+    out = filterVisibilityOnce(prev, audience);
+    if (out === prev) break;
+  }
+  return out;
+}
+
+module.exports = { filterVisibility };

package/vendored/workspace-package-lock.json

@@ -2980,19 +2980,19 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.343",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.343.tgz",
-      "integrity": "sha512-YHnQ3MXI08icvL9ZKnEBy05F2EQ8ob01UaMOuMbM8l+4UcAq6MPPbBTJBbsBUg3H8JeZNt+O4fjsoWth3p6IFg==",
+      "version": "1.5.344",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.344.tgz",
+      "integrity": "sha512-4MxfbmNDm+KPh066EZy+eUnkcDPcZ35wNmOWzFuh/ijvHsve6kbLTLURy88uCNK5FbpN+yk2nQY6BYh1GEt+wg==",
       "license": "ISC"
     },
     "node_modules/enhanced-resolve": {
-      "version": "5.20.1",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.20.1.tgz",
-      "integrity": "sha512-Qohcme7V1inbAfvjItgw0EaxVX5q2rdVEZHRBrEQdRZTssLDGsL8Lwrznl8oQ/6kuTJONLaDcGjkNP247XEhcA==",
+      "version": "5.21.0",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.21.0.tgz",
+      "integrity": "sha512-otxSQPw4lkOZWkHpB3zaEQs6gWYEsmX4xQF68ElXC/TWvGxGMSGOvoNbaLXm6/cS/fSfHtsEdw90y20PCd+sCA==",
       "license": "MIT",
       "dependencies": {
         "graceful-fs": "^4.2.4",
-        "tapable": "^2.3.0"
+        "tapable": "^2.3.3"
       },
       "engines": {
         "node": ">=10.13.0"