jamdesk 1.1.124 → 1.1.126

package/dist/lib/verbose-hint.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `-v`/`--verbose` is a global modifier flag consumed by subcommands
+ * (validate, dev, broken-links, …) via `program.opts().verbose`, not a
+ * standalone action. Invoked alone (`jamdesk -v`), Commander parses
+ * verbose=true, finds no command to run, and falls through to generic help —
+ * which reads to users as "the flag does nothing".
+ *
+ * The flag spelling lives here once, in VERBOSE_FLAGS: index.ts builds its
+ * Commander option from VERBOSE_OPTION_SPEC and this predicate matches the
+ * same tokens, so a rename can't silently desync the option declaration from
+ * the standalone-invocation guard.
+ */
+export declare const VERBOSE_FLAGS: string[];
+/** Commander option spec for the verbose flag, passed to `.option()`. */
+export declare const VERBOSE_OPTION_SPEC: string;
+/**
+ * True only when there is at least one arg and every arg is a verbose flag —
+ * i.e. verbose with no subcommand. Bare `jamdesk` (no args) is false: the user
+ * didn't ask for verbose, so plain help is the right response and the hint
+ * would be noise.
+ */
+export declare function isVerboseOnlyInvocation(args: string[]): boolean;
+/** Hint shown for a standalone `-v`/`--verbose` (see isVerboseOnlyInvocation). */
+export declare const VERBOSE_HINT = "-v/--verbose adds detail to a command \u2014 e.g. `jamdesk validate -v`. For the version number, use -V or --version.";
+//# sourceMappingURL=verbose-hint.d.ts.map

package/dist/lib/verbose-hint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verbose-hint.d.ts","sourceRoot":"","sources":["../../src/lib/verbose-hint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,UAAsB,CAAC;AAEjD,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,QAA2B,CAAC;AAE5D;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAE/D;AAED,kFAAkF;AAClF,eAAO,MAAM,YAAY,0HAC2F,CAAC"}

package/dist/lib/verbose-hint.js

@@ -0,0 +1,27 @@
+/**
+ * `-v`/`--verbose` is a global modifier flag consumed by subcommands
+ * (validate, dev, broken-links, …) via `program.opts().verbose`, not a
+ * standalone action. Invoked alone (`jamdesk -v`), Commander parses
+ * verbose=true, finds no command to run, and falls through to generic help —
+ * which reads to users as "the flag does nothing".
+ *
+ * The flag spelling lives here once, in VERBOSE_FLAGS: index.ts builds its
+ * Commander option from VERBOSE_OPTION_SPEC and this predicate matches the
+ * same tokens, so a rename can't silently desync the option declaration from
+ * the standalone-invocation guard.
+ */
+export const VERBOSE_FLAGS = ['-v', '--verbose'];
+/** Commander option spec for the verbose flag, passed to `.option()`. */
+export const VERBOSE_OPTION_SPEC = VERBOSE_FLAGS.join(', ');
+/**
+ * True only when there is at least one arg and every arg is a verbose flag —
+ * i.e. verbose with no subcommand. Bare `jamdesk` (no args) is false: the user
+ * didn't ask for verbose, so plain help is the right response and the hint
+ * would be noise.
+ */
+export function isVerboseOnlyInvocation(args) {
+    return args.length > 0 && args.every((a) => VERBOSE_FLAGS.includes(a));
+}
+/** Hint shown for a standalone `-v`/`--verbose` (see isVerboseOnlyInvocation). */
+export const VERBOSE_HINT = '-v/--verbose adds detail to a command — e.g. `jamdesk validate -v`. For the version number, use -V or --version.';
+//# sourceMappingURL=verbose-hint.js.map

package/dist/lib/verbose-hint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verbose-hint.js","sourceRoot":"","sources":["../../src/lib/verbose-hint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;AAEjD,yEAAyE;AACzE,MAAM,CAAC,MAAM,mBAAmB,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAc;IACpD,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,kFAAkF;AAClF,MAAM,CAAC,MAAM,YAAY,GACvB,kHAAkH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jamdesk",
-  "version": "1.1.124",
+  "version": "1.1.126",
   "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/components/navigation/PageNavigation.tsx

@@ -2,7 +2,7 @@
 
 import { useMemo } from 'react';
 import Link from 'next/link';
-import type { DocsConfig, NavigationPage, GroupConfig } from '@/lib/docs-types';
+import type { DocsConfig, NavigationPage, NavigationPageObject, GroupConfig } from '@/lib/docs-types';
 import { normalizeNavPage } from '@/lib/docs-types';
 import { useLinkPrefix } from '@/lib/link-prefix-context';
 
@@ -13,89 +13,86 @@ interface PageNavigationProps {
 }
 
 /**
- * Extract all pages from navigation structure
+ * Extract all visible pages from the navigation structure, in sidebar order.
+ *
+ * Hidden pages (frontmatter `hidden: true` propagated onto the nav page object
+ * by enhance-navigation) and hidden tabs/anchors/groups are skipped so the
+ * prev/next pager mirrors the sidebar — it never links into hidden content,
+ * matching the sidebar filter in navigation-resolver. `searchable: true` only
+ * keeps a hidden node in artifacts; it does NOT bring it back into the pager.
  */
-function extractAllPages(config: DocsConfig): { path: string; title: string }[] {
+export function extractAllPages(config: DocsConfig): { path: string; title: string }[] {
   const allPages: { path: string; title: string }[] = [];
   const nav = config.navigation;
-  
+
+  function pushPage(item: NavigationPage) {
+    if (typeof item !== 'string' && (item as NavigationPageObject & { hidden?: boolean }).hidden === true) {
+      return;
+    }
+    const { path, title } = normalizeNavPage(item);
+    allPages.push({ path, title });
+  }
+
+  function extractFromPagesArray(pages: (NavigationPage | GroupConfig)[]) {
+    for (const item of pages) {
+      if (typeof item === 'string' || 'page' in item) {
+        pushPage(item as NavigationPage);
+      } else if ('group' in item) {
+        extractFromGroup(item as GroupConfig);
+      }
+    }
+  }
+
   // Helper to extract pages from a group (including nested groups)
   function extractFromGroup(group: GroupConfig) {
+    if (group.hidden === true) return; // hidden groups are dropped from nav + pager
     if (group.pages) {
-      for (const item of group.pages) {
-        if (typeof item === 'string' || 'page' in item) {
-          // It's a page
-          const { path, title } = normalizeNavPage(item as NavigationPage);
-          allPages.push({ path, title });
-        } else if ('group' in item) {
-          // It's a nested group
-          extractFromGroup(item);
-        }
-      }
+      extractFromPagesArray(group.pages as (NavigationPage | GroupConfig)[]);
     }
   }
-  
+
   // Extract from anchors
   if (nav.anchors) {
     for (const anchor of nav.anchors) {
+      if ((anchor as { hidden?: boolean }).hidden === true) continue;
       if (anchor.groups) {
         for (const group of anchor.groups) {
           extractFromGroup(group);
         }
       }
       if (anchor.pages) {
-        for (const item of anchor.pages) {
-          if (typeof item === 'string' || 'page' in item) {
-            const { path, title } = normalizeNavPage(item as NavigationPage);
-            allPages.push({ path, title });
-          } else if ('group' in item) {
-            extractFromGroup(item);
-          }
-        }
+        extractFromPagesArray(anchor.pages as (NavigationPage | GroupConfig)[]);
       }
     }
   }
-  
+
   // Extract from tabs
   if (nav.tabs) {
     for (const tab of nav.tabs) {
+      if ((tab as { hidden?: boolean }).hidden === true) continue;
       if (tab.groups) {
         for (const group of tab.groups) {
           extractFromGroup(group);
         }
       }
       if (tab.pages) {
-        for (const item of tab.pages) {
-          if (typeof item === 'string' || 'page' in item) {
-            const { path, title } = normalizeNavPage(item as NavigationPage);
-            allPages.push({ path, title });
-          } else if ('group' in item) {
-            extractFromGroup(item);
-          }
-        }
+        extractFromPagesArray(tab.pages as (NavigationPage | GroupConfig)[]);
       }
     }
   }
-  
+
   // Extract from top-level groups
   if (nav.groups) {
     for (const group of nav.groups) {
       extractFromGroup(group);
     }
   }
-  
+
   // Extract from top-level pages
   if (nav.pages) {
-    for (const item of nav.pages) {
-      if (typeof item === 'string' || 'page' in item) {
-        const { path, title } = normalizeNavPage(item as NavigationPage);
-        allPages.push({ path, title });
-      } else if ('group' in item) {
-        extractFromGroup(item);
-      }
-    }
+    extractFromPagesArray(nav.pages as (NavigationPage | GroupConfig)[]);
   }
-  
+
   return allPages;
 }
 

package/vendored/lib/docs-types.ts

@@ -165,6 +165,8 @@ export interface GroupConfig {
   group: string;
   icon?: IconConfig;
   hidden?: boolean;
+  /** When true on a hidden group, descendants stay in search/sitemap/AI context. */
+  searchable?: boolean;
   root?: string;
   tag?: string;
   expanded?: boolean;
@@ -202,6 +204,8 @@ export interface TabConfig {
   tab: string;
   icon?: IconConfig;
   hidden?: boolean;
+  /** When true on a hidden tab, descendants stay in search/sitemap/AI context. */
+  searchable?: boolean;
   href?: string;
   groups?: GroupConfig[];
   pages?: (NavigationPage | GroupConfig)[];

package/vendored/lib/enhance-navigation.ts

@@ -88,14 +88,23 @@ function enhancePage(
     existing.method || parseApiMethod(fm.api) || parseOpenApiMethod(fm.openapi);
   const icon = existing.icon || (fm.icon as string | undefined);
   const tag = existing.tag || (fm.tag as string | undefined);
+  // hidden: explicit nav-level setting wins, otherwise inherit from frontmatter
+  const existingHidden = (existing as { hidden?: boolean }).hidden;
+  let hidden: boolean | undefined;
+  if (typeof existingHidden === 'boolean') {
+    hidden = existingHidden;
+  } else if (fm.hidden === true) {
+    hidden = true;
+  }
 
-  if (title || method || icon || tag) {
+  if (title || method || icon || tag || hidden !== undefined) {
     return {
       page: pagePath,
       ...(title && { title }),
       ...(method && { method }),
       ...(icon && { icon }),
       ...(tag && { tag }),
+      ...(hidden !== undefined && { hidden }),
     };
   }
 

package/vendored/lib/navigation-resolver.ts

@@ -194,11 +194,19 @@ function resolvePages(pages: (NavigationPage | GroupConfig)[]): {
 
   for (const item of pages) {
     if (typeof item === 'string' || 'page' in item) {
+      // Skip page objects explicitly marked hidden
+      if (typeof item !== 'string' && (item as NavigationPageObject & { hidden?: boolean }).hidden === true) {
+        continue;
+      }
       // It's a page
       const resolved = resolvePage(item as NavigationPage);
       resolvedPages.push(resolved);
       items.push({ type: 'page', page: resolved });
     } else if ('group' in item) {
+      // Skip hidden nested groups
+      if (item.hidden === true) {
+        continue;
+      }
       // It's a nested group
       const resolved = resolveGroup(item);
       nestedGroups.push(resolved);
@@ -234,6 +242,7 @@ function resolveTabGroups(tab: TabConfig): ResolvedGroup[] {
   
   if (tab.groups) {
     for (const group of tab.groups) {
+      if (group.hidden === true) continue;
       groups.push(resolveGroup(group));
     }
   }
@@ -424,8 +433,9 @@ export function resolveNavigation(
     // If no language detected in path, use default
     currentLanguage = detectedLang || defaultLang;
 
-    // Build resolved languages array
+    // Build resolved languages array (skip hidden languages from the selector)
     for (const langConfig of config.navigation.languages) {
+      if (langConfig.hidden === true) continue;
       const displayInfo = getLanguageDisplayInfo(langConfig.language);
       resolvedLanguages.push({
         code: langConfig.language,
@@ -450,16 +460,19 @@ export function resolveNavigation(
 
   // Resolve top-level external anchors (from config.anchors)
   if (config.anchors && Array.isArray(config.anchors)) {
-    result.externalAnchors = config.anchors.map((anchor: ExternalAnchorConfig) => ({
-      name: anchor.name,
-      href: anchor.href,
-      icon: getIconName(anchor.icon),
-    }));
+    result.externalAnchors = config.anchors
+      .filter((anchor: ExternalAnchorConfig & { hidden?: boolean }) => anchor.hidden !== true)
+      .map((anchor: ExternalAnchorConfig) => ({
+        name: anchor.name,
+        href: anchor.href,
+        icon: getIconName(anchor.icon),
+      }));
   }
 
   // Check for global.anchors (external links)
   if (navigation.global?.anchors) {
     for (const anchor of navigation.global.anchors) {
+      if (anchor.hidden === true) continue;
       result.externalAnchors.push({
         name: anchor.anchor,
         href: anchor.href,
@@ -483,21 +496,24 @@ export function resolveNavigation(
     return true;
   });
 
-  // Resolve top-level tabs
+  // Resolve top-level tabs — hidden tabs are excluded from the sidebar and cannot be active
   if (navigation.tabs) {
-    result.tabs = navigation.tabs.map(resolveTab);
-    result.activeTab = findActiveTab(navigation.tabs, pathname);
+    const visibleTabs = navigation.tabs.filter(t => t.hidden !== true);
+    result.tabs = visibleTabs.map(resolveTab);
+    result.activeTab = findActiveTab(visibleTabs, pathname);
 
     // Only get groups from the active tab
-    const activeTabConfig = navigation.tabs.find(t => t.tab === result.activeTab);
+    const activeTabConfig = visibleTabs.find(t => t.tab === result.activeTab);
     if (activeTabConfig) {
       result.groups.push(...resolveTabGroups(activeTabConfig));
     }
   }
 
-  // Resolve top-level groups
+  // Resolve top-level groups (hidden groups are excluded from the sidebar)
   if (navigation.groups) {
-    result.groups.push(...navigation.groups.map(resolveGroup));
+    result.groups.push(
+      ...navigation.groups.filter(g => g.hidden !== true).map(resolveGroup),
+    );
   }
 
   // Resolve top-level pages

package/vendored/lib/search.ts

@@ -67,6 +67,24 @@ function extractSections(content: string): { heading: string; content: string }[
   return sections;
 }
 
+/**
+ * Build an in-memory search index by scanning the local `content/` directory.
+ *
+ * This is the runtime fallback for when the prebuilt R2 search-data.json
+ * artifact is unavailable (e.g. first request before build completes or in
+ * local dev). It intentionally mirrors the filtering logic in
+ * lib/static-artifacts.ts:generateSearchData — keep both in sync per the
+ * search-index sync chain documented in builder/CLAUDE.md.
+ *
+ * Frontmatter-level visibility (hidden / noindex / seo.noindex) IS honored
+ * here, matching build-search-index.cjs and generateSearchData.
+ *
+ * NOTE: Unlike generateSearchData, this fallback does NOT have access to
+ * VisibilityInputs (no config or nav tree available at request time). Pages
+ * hidden only via nav-tree hidden:true or seo.indexHiddenPages will therefore
+ * still appear in this fallback's results but NOT in the built artifact. This
+ * is acceptable — local dev search is documented as "production only".
+ */
 export function buildSearchIndex(): SearchResult[] {
   const documents: SearchResult[] = [];
   const contentDir = path.join(process.cwd(), 'content');
@@ -87,6 +105,16 @@ export function buildSearchIndex(): SearchResult[] {
         const fileContents = fs.readFileSync(filePath, 'utf8');
         const { data, content } = parseFrontmatterLenient(fileContents);
 
+        // Frontmatter-level visibility: skip author-hidden / noindexed pages,
+        // mirroring build-search-index.cjs and generateSearchData.
+        if (
+          data.hidden === true ||
+          data.noindex === true ||
+          (data.seo as { noindex?: boolean } | undefined)?.noindex === true
+        ) {
+          continue;
+        }
+
         // Filter for="agents" content out of the search index.
         const visibleContent = filterVisibility(content, 'humans');
         const sections = extractSections(visibleContent);

package/vendored/lib/seo.ts

@@ -618,17 +618,24 @@ export function buildSeoMetadata(
   // 1. Generator - always add
   metadata.generator = 'Jamdesk';
 
-  // 2. Robots (priority: page > global)
-  // Page noindex can be set via frontmatter.noindex or frontmatter.seo.noindex
-  const pageNoindex = frontmatter.noindex ?? frontmatter.seo?.noindex;
-  if (pageNoindex === true) {
+  // 2. Robots (priority: explicit page > hidden auto-noindex > global)
+  // Explicit page noindex via frontmatter.noindex or frontmatter.seo.noindex always wins.
+  // hidden: true implies noindex,follow UNLESS the project opts hidden pages into
+  // indexing via seo.indexHiddenPages: true or seo.indexing: 'all'.
+  const explicitPageNoindex = frontmatter.noindex ?? frontmatter.seo?.noindex;
+  const projectIndexesHidden =
+    config.seo?.indexHiddenPages === true || config.seo?.indexing === 'all';
+  const hiddenImpliesNoindex = frontmatter.hidden === true && !projectIndexesHidden;
+  const effectiveNoindex = explicitPageNoindex ?? (hiddenImpliesNoindex ? true : undefined);
+
+  if (effectiveNoindex === true) {
     // noindex does NOT imply nofollow - use follow: true
     metadata.robots = { index: false, follow: true };
-  } else if (pageNoindex !== false && metatags.robots) {
+  } else if (effectiveNoindex !== false && metatags.robots) {
     // Page didn't explicitly set noindex: false, so use global robots
     metadata.robots = metatags.robots;
   }
-  // If pageNoindex === false, it overrides any global noindex (no robots meta = index)
+  // If effectiveNoindex === false, it overrides any global noindex (no robots meta = index)
 
   // 3. Googlebot (separate from robots)
   if (metatags.googlebot) {

package/vendored/lib/static-artifacts.ts

@@ -14,6 +14,7 @@ import {
   resolveLocaleWithLoweredSet,
 } from './language-utils.js';
 import { buildHreflangAlternates } from './seo.js';
+import { computePageVisibility, type VisibilityInputs } from './visibility.js';
 
 /**
  * Page metadata for artifact generation.
@@ -52,16 +53,45 @@ export interface SitemapOptions {
    * localization signal (in addition to in-page hreflang link tags).
    */
   languages?: LanguageConfig[];
+  /**
+   * Visibility inputs from lib/visibility.ts. When provided, filtering
+   * delegates to computePageVisibility for consistent hidden/orphan/searchable
+   * handling across all artifacts. Falls back to simple noindex+hidden check
+   * when omitted (legacy behavior for call sites not yet wired to build.ts).
+   */
+  visibility?: VisibilityInputs;
+}
+
+/**
+ * Decide whether a PageMetadata entry belongs in an artifact.
+ *
+ * When visibility inputs are present, delegates to computePageVisibility for
+ * consistent hidden/orphan/searchable handling. Otherwise falls back to the
+ * legacy noindex+hidden check. Shared by sitemap and llms.txt so both apply the
+ * same rule (PageMetadata has no per-page seo.noindex, so it's passed undefined).
+ */
+function isPageMetadataIncluded(page: PageMetadata, visibility?: VisibilityInputs): boolean {
+  if (!visibility) {
+    return !page.noindex && !page.hidden;
+  }
+  return computePageVisibility(
+    page.path,
+    { hidden: page.hidden, noindex: page.noindex, seo: { noindex: undefined } },
+    visibility,
+  ).inArtifacts;
 }
 
 /**
  * Generate sitemap.xml from page metadata.
  *
+ * Filtering delegates to lib/visibility.ts when visibility inputs are provided,
+ * giving consistent hidden/orphan/searchable handling across all artifacts.
+ *
  * @param options - Sitemap options
  * @returns XML string
  */
 export function generateSitemap(options: SitemapOptions): string {
-  const { baseUrl, pages, hostAtDocs = false, noindex = false, languages } = options;
+  const { baseUrl, pages, hostAtDocs = false, noindex = false, languages, visibility } = options;
 
   if (noindex) {
     return `<?xml version="1.0" encoding="UTF-8"?>
@@ -77,7 +107,7 @@ export function generateSitemap(options: SitemapOptions): string {
     : 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
 
   const entries = pages
-    .filter(p => !p.noindex && !p.hidden)
+    .filter(p => isPageMetadataIncluded(p, visibility))
     .map(p => {
       const url = `${baseUrl}${urlPrefix}/${p.path}`;
       const lastmod = p.lastModified || new Date().toISOString().split('T')[0];
@@ -129,16 +159,25 @@ export interface LlmsTxtOptions {
   hostAtDocs?: boolean;
   /** Block all crawlers - generates empty llms.txt */
   noindex?: boolean;
+  /**
+   * Visibility inputs from lib/visibility.ts. When provided, filtering
+   * delegates to computePageVisibility for consistent hidden/orphan/searchable
+   * handling across all artifacts.
+   */
+  visibility?: VisibilityInputs;
 }
 
 /**
  * Generate llms.txt following https://llmstxt.org/ spec.
  *
+ * Filtering delegates to lib/visibility.ts when visibility inputs are provided,
+ * giving consistent hidden/orphan/searchable handling across all artifacts.
+ *
  * @param options - LLMs.txt options
  * @returns Plain text string
  */
 export function generateLlmsTxt(options: LlmsTxtOptions): string {
-  const { name, description, baseUrl, pages, hostAtDocs = false, noindex = false } = options;
+  const { name, description, baseUrl, pages, hostAtDocs = false, noindex = false, visibility } = options;
 
   if (noindex) {
     return '';
@@ -153,7 +192,7 @@ export function generateLlmsTxt(options: LlmsTxtOptions): string {
   }
 
   for (const page of pages) {
-    if (page.noindex || page.hidden) continue;
+    if (!isPageMetadataIncluded(page, visibility)) continue;
 
     const url = `${baseUrl}${urlPrefix}/${page.path}.md`;
     const desc = page.description ? `: ${page.description}` : '';
@@ -317,22 +356,34 @@ export interface LlmsFullTxtOptions {
   pages: LlmsFullPageInfo[];
   /** Block all crawlers - generates empty file */
   noindex?: boolean;
+  /**
+   * Visibility inputs from lib/visibility.ts. When provided, filtering
+   * delegates to computePageVisibility for consistent hidden/orphan/searchable
+   * handling across all artifacts.
+   */
+  visibility?: VisibilityInputs;
 }
 
 /**
  * Generate llms-full.txt with complete documentation content for LLM context windows.
  * Follows https://llmstxt.org/ spec.
+ *
+ * Filtering delegates to lib/visibility.ts when visibility inputs are provided,
+ * giving consistent hidden/orphan/searchable handling across all artifacts.
  */
 export function generateLlmsFullTxt(options: LlmsFullTxtOptions): string {
-  const { name, pages, noindex = false } = options;
+  const { name, pages, noindex = false, visibility } = options;
 
   if (noindex) {
     return '';
   }
 
-  const visiblePages = pages.filter(p =>
-    !p.frontmatter.noindex && !p.frontmatter.hidden && !p.frontmatter.seo?.noindex
-  );
+  const visiblePages = pages.filter(p => {
+    const path = p.path.replace(/\.mdx?$/, '');
+    return visibility
+      ? computePageVisibility(path, p.frontmatter as never, visibility).inArtifacts
+      : !p.frontmatter.noindex && !p.frontmatter.hidden && !p.frontmatter.seo?.noindex;
+  });
 
   const parts: string[] = [
     `# ${name} - Complete Documentation\n\n`,
@@ -384,6 +435,14 @@ export interface GenerateAllOptions {
   llmsFullPages?: LlmsFullPageInfo[];
   /** Language configurations (forwarded to sitemap for hreflang siblings) */
   languages?: LanguageConfig[];
+  /**
+   * Visibility inputs from lib/visibility.ts. When provided, all artifact
+   * generators use computePageVisibility for consistent hidden/orphan/searchable
+   * filtering. The production caller (build.ts) always passes this; the legacy
+   * fallback (simple noindex+hidden check) exists for test call sites that
+   * construct minimal options objects.
+   */
+  visibility?: VisibilityInputs;
 }
 
 /**
@@ -400,20 +459,26 @@ export interface GeneratedArtifacts {
 /**
  * Generate all static artifacts for a project.
  *
+ * When visibility inputs are provided (always in production via build.ts), all
+ * generators use computePageVisibility from lib/visibility.ts for consistent
+ * hidden/orphan/searchable filtering across sitemap, llms.txt, llms-full.txt,
+ * and search index.
+ *
  * @param options - Generation options
  * @returns Object with all generated artifacts
  */
 export function generateAllArtifacts(options: GenerateAllOptions): GeneratedArtifacts {
   const {
     baseUrl, name, description, pages, hostAtDocs, noindex, rssPages, llmsFullPages, languages,
+    visibility,
   } = options;
 
-  const sitemap = generateSitemap({ baseUrl, pages, hostAtDocs, noindex, languages });
+  const sitemap = generateSitemap({ baseUrl, pages, hostAtDocs, noindex, languages, visibility });
   const llmsTxt = generateLlmsTxt({
-    name, description, baseUrl, pages, hostAtDocs, noindex,
+    name, description, baseUrl, pages, hostAtDocs, noindex, visibility,
   });
   const llmsFullTxt = llmsFullPages
-    ? generateLlmsFullTxt({ name, pages: llmsFullPages, noindex })
+    ? generateLlmsFullTxt({ name, pages: llmsFullPages, noindex, visibility })
     : '';
   const robotsTxt = generateRobotsTxt({ baseUrl, hostAtDocs, noindex });
 
@@ -724,15 +789,21 @@ export function extractSections(content: string): Array<{ heading: string; conte
 /**
  * Generate search data from page content.
  *
+ * Filtering delegates to lib/visibility.ts when visibility inputs are provided,
+ * giving consistent hidden/orphan/searchable handling across all artifacts.
+ * Keep this filter in sync with lib/search.ts:buildSearchIndex (runtime fallback).
+ *
  * @param pages - Array of page info with content
  * @param projectLanguages - Language codes declared in docs.json.navigation.languages.
  *   Used as the locale whitelist; slugs whose prefix is not in this list are
  *   tagged as default-language (locale='').
+ * @param visibility - Optional visibility inputs; when omitted all pages are included.
  * @returns JSON string of search documents
  */
 export function generateSearchData(
   pages: SearchPageInfo[],
   projectLanguages: readonly string[],
+  visibility?: VisibilityInputs,
 ): string {
   const documents: SearchDocument[] = [];
   const loweredLanguages = buildLoweredLocaleSet(projectLanguages);
@@ -740,6 +811,16 @@ export function generateSearchData(
   for (const page of pages) {
     const pathWithoutExt = page.path.replace(/\.mdx?$/, '');
     const slug = pathWithoutExt.replace(/\\/g, '/');
+
+    // Skip pages excluded by the visibility module when inputs are available.
+    if (visibility && !computePageVisibility(
+      slug,
+      page.frontmatter as never,
+      visibility,
+    ).inArtifacts) {
+      continue;
+    }
+
     const pageType = inferPageType(slug);
     const locale = resolveLocaleWithLoweredSet(slug, loweredLanguages);
     // Filter for="agents" content out of the search index — the site