radiant-docs 0.1.39 → 0.1.41

package/template/src/lib/assistant-panel-config.ts

@@ -0,0 +1,80 @@
+import {
+  type AssistantChromeConfig,
+  getAssistantChromeConfig,
+} from "./assistant-chrome";
+import { withBasePath } from "./base-path";
+import { getAssistantLauncherIconConfig } from "./assistant-embed-script";
+import type { DocsConfig } from "./validation";
+
+export type AssistantPanelRuntimeConfig = {
+  apiPath: string;
+  docsTitle: string;
+  isChatAvailable: boolean;
+  canSendChatRequest: boolean;
+  launcherThemeColor: string;
+  launcherThemeColors: {
+    light: string;
+    dark: string;
+  };
+  launcherIconColor: string;
+  launcherIconColors: {
+    light: string;
+    dark: string;
+  };
+  launcherIconImageSrc: string;
+  emptyStateHeading?: string;
+  emptyStateQuestions?: string[];
+  devProxyToken?: string;
+  chrome: AssistantChromeConfig;
+};
+
+export function getAssistantPanelRuntimeConfig(
+  config: DocsConfig,
+): AssistantPanelRuntimeConfig {
+  const assistantLauncherIcon = getAssistantLauncherIconConfig(config);
+  const assistantConfig = config.assistant;
+  const parsedOrgTier = Number.parseInt(
+    (import.meta.env.ORG_TIER ?? "1").toString(),
+    10,
+  );
+  const orgTier =
+    Number.isFinite(parsedOrgTier) && parsedOrgTier > 0 ? parsedOrgTier : 1;
+  const isDev = import.meta.env.DEV;
+  const assistantDevHost = (import.meta.env.ASK_AI_DEV_HOST ?? "")
+    .toString()
+    .trim();
+  const assistantDevProxySecret = (
+    import.meta.env.ASK_AI_DEV_PROXY_SECRET ?? ""
+  )
+    .toString()
+    .trim();
+  const hasAssistantDevConfig =
+    assistantDevHost.length > 0 && assistantDevProxySecret.length > 0;
+  const isChatAvailable = isDev || orgTier >= 3;
+  const canSendChatRequest = isDev ? hasAssistantDevConfig : orgTier >= 3;
+  let apiPath = withBasePath("/_platform/assistant");
+
+  if (isDev && hasAssistantDevConfig) {
+    try {
+      apiPath = new URL("/_platform/assistant", assistantDevHost).toString();
+    } catch {
+      apiPath = withBasePath("/_platform/assistant");
+    }
+  }
+
+  return {
+    apiPath,
+    docsTitle: config.title,
+    isChatAvailable,
+    canSendChatRequest,
+    launcherThemeColor: assistantLauncherIcon.themeColor,
+    launcherThemeColors: assistantLauncherIcon.themeColors,
+    launcherIconColor: assistantLauncherIcon.color,
+    launcherIconColors: assistantLauncherIcon.colors,
+    launcherIconImageSrc: assistantLauncherIcon.imageSrc,
+    emptyStateHeading: assistantConfig?.heading,
+    emptyStateQuestions: assistantConfig?.questions,
+    devProxyToken: isDev ? assistantDevProxySecret : undefined,
+    chrome: getAssistantChromeConfig(config),
+  };
+}

package/template/src/lib/base-path.ts

@@ -0,0 +1,98 @@
+const EXTERNAL_PROTOCOL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
+
+declare global {
+  // Set by astro.config.mjs so build-time MDX remark plugins can see the
+  // configured base before Astro injects import.meta.env.BASE_URL.
+  var __RADIANT_DOCS_BASE_PATH__: string | undefined;
+}
+
+export function normalizeBasePath(value: string | null | undefined): string {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed || trimmed === "/") return "";
+
+  const pathname = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  const normalized = pathname.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+  return normalized === "/" ? "" : normalized;
+}
+
+export function getDocsBasePath(): string {
+  const astroBasePath = normalizeBasePath(import.meta.env.BASE_URL);
+  return (
+    astroBasePath ||
+    normalizeBasePath(globalThis.__RADIANT_DOCS_BASE_PATH__)
+  );
+}
+
+function splitPathSuffix(value: string): { pathname: string; suffix: string } {
+  const match = value.match(/^([^?#]*)(.*)$/);
+  return {
+    pathname: match?.[1] ?? value,
+    suffix: match?.[2] ?? "",
+  };
+}
+
+function isExternalOrDocumentLocalHref(value: string): boolean {
+  if (!value) return true;
+  if (value.startsWith("#") || value.startsWith("?")) return true;
+  if (value.startsWith("//")) return true;
+  if (value.startsWith("./") || value.startsWith("../")) return true;
+  return EXTERNAL_PROTOCOL_REGEX.test(value);
+}
+
+function applyBasePath(
+  href: string,
+  options: { preserveAlreadyPrefixed: boolean },
+): string {
+  const value = href.trim();
+  if (!value || isExternalOrDocumentLocalHref(value)) {
+    return href;
+  }
+
+  const basePath = getDocsBasePath();
+  if (!basePath) {
+    return value;
+  }
+
+  const { pathname, suffix } = splitPathSuffix(value);
+  const normalizedPathname = pathname.startsWith("/")
+    ? pathname
+    : `/${pathname}`;
+
+  if (
+    options.preserveAlreadyPrefixed &&
+    (normalizedPathname === basePath ||
+      normalizedPathname.startsWith(`${basePath}/`))
+  ) {
+    return `${normalizedPathname}${suffix}`;
+  }
+
+  if (normalizedPathname === "/") {
+    return `${basePath}${suffix}`;
+  }
+
+  return `${basePath}${normalizedPathname}${suffix}`;
+}
+
+export function withBasePath(href: string): string {
+  return applyBasePath(href, { preserveAlreadyPrefixed: true });
+}
+
+export function prependBasePath(href: string): string {
+  return applyBasePath(href, { preserveAlreadyPrefixed: false });
+}
+
+export function stripBasePath(pathname: string): string {
+  const value = pathname || "/";
+  const basePath = getDocsBasePath();
+  if (!basePath) return value;
+
+  if (value === basePath) {
+    return "/";
+  }
+
+  if (value.startsWith(`${basePath}/`)) {
+    return value.slice(basePath.length) || "/";
+  }
+
+  return value;
+}

package/template/src/lib/component-error.ts

@@ -85,27 +85,33 @@ export function validateType(
   componentName: string,
   propName: string,
   value: unknown,
-  expectedType: "string" | "number" | "boolean" | "object" | "array",
+  expectedType:
+    | "string"
+    | "number"
+    | "boolean"
+    | "object"
+    | "array"
+    | readonly ("string" | "number" | "boolean" | "object" | "array")[],
   pathname: string
 ): void {
   // Skip if undefined (optional props)
   if (value === undefined) return;
 
-  let isValid = false;
-
-  if (expectedType === "array") {
-    isValid = Array.isArray(value);
-  } else {
-    isValid = typeof value === expectedType;
-  }
+  const expectedTypes = Array.isArray(expectedType)
+    ? expectedType
+    : [expectedType];
+  const isValid = expectedTypes.some((type) =>
+    type === "array" ? Array.isArray(value) : typeof value === type
+  );
 
   if (!isValid) {
     const sourceFile = getSourceFile(pathname);
     const actualType = Array.isArray(value) ? "array" : typeof value;
+    const expectedTypeLabel = expectedTypes.join(" or ");
     throw new Error(
       formatError(
         componentName,
-        `Invalid prop "${propName}": expected ${expectedType}, got ${actualType}`,
+        `Invalid prop "${propName}": expected ${expectedTypeLabel}, got ${actualType}`,
         sourceFile
       )
     );
@@ -123,10 +129,43 @@ export function validateType(
  */
 export type PropSchema = {
   required?: boolean;
-  type?: "string" | "number" | "boolean" | "object" | "array";
+  type?:
+    | "string"
+    | "number"
+    | "boolean"
+    | "object"
+    | "array"
+    | readonly ("string" | "number" | "boolean" | "object" | "array")[];
   enum?: readonly string[];
 };
 
+/**
+ * Validates that no unsupported props are passed to a component.
+ */
+export function validateNoUnknownProps(
+  componentName: string,
+  props: Record<string, unknown>,
+  allowedProps: readonly string[],
+  pathname: string
+): void {
+  const allowed = new Set(allowedProps);
+  const unknownProps = Object.keys(props).filter((key) => !allowed.has(key));
+
+  if (unknownProps.length === 0) return;
+
+  const sourceFile = getSourceFile(pathname);
+  const unknownLabel = unknownProps.map((name) => `"${name}"`).join(", ");
+  const allowedLabel = allowedProps.map((name) => `"${name}"`).join(", ");
+  const propLabel = unknownProps.length === 1 ? "prop" : "props";
+  throw new Error(
+    formatError(
+      componentName,
+      `Unsupported ${propLabel}: ${unknownLabel}. Allowed props: ${allowedLabel}`,
+      sourceFile
+    )
+  );
+}
+
 export function validateProps(
   componentName: string,
   props: Record<string, unknown>,

package/template/src/lib/favicon.ts

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export type FaviconConfig = {
+  href: string;
+  type: string;
+};
+
+const DOCS_DIR = path.join(process.cwd(), "src/content/docs");
+const DEFAULT_FAVICON: FaviconConfig = {
+  href: "/favicon.svg",
+  type: "image/svg+xml",
+};
+
+const FAVICON_CANDIDATES: FaviconConfig[] = [
+  DEFAULT_FAVICON,
+  { href: "/favicon.ico", type: "image/x-icon" },
+  { href: "/favicon.png", type: "image/png" },
+  { href: "/favicon.webp", type: "image/webp" },
+  { href: "/favicon.avif", type: "image/avif" },
+  { href: "/favicon.jpg", type: "image/jpeg" },
+  { href: "/favicon.jpeg", type: "image/jpeg" },
+];
+
+export function getFaviconConfig(): FaviconConfig {
+  const favicon = FAVICON_CANDIDATES.find((candidate) =>
+    fs.existsSync(path.join(DOCS_DIR, candidate.href.replace(/^\/+/, ""))),
+  );
+
+  return favicon ?? DEFAULT_FAVICON;
+}

package/template/src/lib/mdx/remark-resolve-internal-links.ts

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import type { Link, Root } from "mdast";
 import type { Plugin } from "unified";
@@ -6,15 +7,17 @@ import {
   getConfig,
   loadOpenApiSpec,
   type DocsConfig,
+  type HiddenPageRoute,
   type NavGroup,
   type NavMenuItem,
   type NavOpenApi,
   type NavOpenApiPage,
   type NavPage,
 } from "../validation";
+import { prependBasePath, withBasePath } from "../base-path";
 import {
   buildMdxPageHref,
-  buildOpenApiEndpointSlug,
+  buildOpenApiEndpointHref,
   parseOpenApiEndpoint,
   slugify,
 } from "../utils";
@@ -25,6 +28,7 @@ type ResolvedRouteIndex = {
   canonicalHrefByFilePath: Map<string, string>;
   allHrefsByFilePath: Map<string, string[]>;
   validRoutePaths: Set<string>;
+  allDocsFilePaths: Set<string>;
 };
 
 type LinkSplit = {
@@ -145,6 +149,38 @@ function getCurrentDocFilePath(filePath: string | undefined): string | null {
   return normalizeDocsFilePath(relativePath);
 }
 
+function collectDocsFilePaths(directory: string): string[] {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const results: string[] = [];
+  for (const entry of entries) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.name.startsWith(".") || entry.name === "node_modules") {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      results.push(...collectDocsFilePaths(entryPath));
+      continue;
+    }
+
+    if (entry.isFile() && /\.(md|mdx)$/i.test(entry.name)) {
+      const relativePath = path.relative(DOCS_ROOT, entryPath);
+      const normalizedFilePath = normalizeDocsFilePath(relativePath);
+      if (normalizedFilePath) {
+        results.push(normalizedFilePath);
+      }
+    }
+  }
+
+  return results;
+}
+
 function buildFilePathCandidates(args: {
   baseHref: string;
   currentDocFilePath: string | null;
@@ -235,11 +271,11 @@ function addMdxRoute(args: {
   }
 
   if (args.homePath && normalizedFilePath === args.homePath) {
-    addValidRoutePath(args.index, "/");
-    if (!aliases.includes("/")) {
-      aliases.unshift("/");
+    const homeHref = addValidRoutePath(args.index, prependBasePath("/"));
+    if (!aliases.includes(homeHref)) {
+      aliases.unshift(homeHref);
     }
-    args.index.canonicalHrefByFilePath.set(normalizedFilePath, "/");
+    args.index.canonicalHrefByFilePath.set(normalizedFilePath, homeHref);
   }
 
   args.index.allHrefsByFilePath.set(normalizedFilePath, aliases);
@@ -251,11 +287,33 @@ function addOpenApiEndpointRoute(args: {
   method: string;
   endpointPath: string;
 }): void {
-  const endpointSlug = buildOpenApiEndpointSlug(args.endpointPath, args.method);
-  const fullSlug = args.parentSlug
-    ? `${args.parentSlug}/${endpointSlug}`
-    : endpointSlug;
-  addValidRoutePath(args.index, fullSlug);
+  addValidRoutePath(
+    args.index,
+    buildOpenApiEndpointHref({
+      path: args.endpointPath,
+      method: args.method,
+      groupSlug: args.parentSlug,
+    }),
+  );
+}
+
+function addHiddenPageRoute(
+  index: ResolvedRouteIndex,
+  route: HiddenPageRoute,
+): void {
+  const normalizedFilePath = normalizeDocsFilePath(route.filePath);
+  if (!normalizedFilePath) return;
+
+  const href = addValidRoutePath(index, prependBasePath(route.href));
+  if (!index.canonicalHrefByFilePath.has(normalizedFilePath)) {
+    index.canonicalHrefByFilePath.set(normalizedFilePath, href);
+  }
+
+  const aliases = index.allHrefsByFilePath.get(normalizedFilePath) ?? [];
+  if (!aliases.includes(href)) {
+    aliases.push(href);
+  }
+  index.allHrefsByFilePath.set(normalizedFilePath, aliases);
 }
 
 function shouldIncludeEndpoint(
@@ -431,13 +489,20 @@ async function processMenuItems(args: {
   }
 }
 
-async function buildRouteIndex(config: DocsConfig): Promise<ResolvedRouteIndex> {
+async function buildRouteIndex(
+  config: DocsConfig,
+): Promise<ResolvedRouteIndex> {
   const index: ResolvedRouteIndex = {
     canonicalHrefByFilePath: new Map<string, string>(),
     allHrefsByFilePath: new Map<string, string[]>(),
     validRoutePaths: new Set<string>(),
+    allDocsFilePaths: new Set<string>(),
   };
 
+  for (const docFilePath of collectDocsFilePaths(DOCS_ROOT)) {
+    index.allDocsFilePaths.add(docFilePath);
+  }
+
   const homePath =
     typeof config.home === "string" ? normalizeDocsFilePath(config.home) : null;
 
@@ -459,7 +524,10 @@ async function buildRouteIndex(config: DocsConfig): Promise<ResolvedRouteIndex>
   }
 
   const rootOpenApi = (config.navigation as any).openapi;
-  if (typeof rootOpenApi === "string" || (rootOpenApi && typeof rootOpenApi === "object")) {
+  if (
+    typeof rootOpenApi === "string" ||
+    (rootOpenApi && typeof rootOpenApi === "object")
+  ) {
     await processOpenApiFile({
       index,
       parentSlug: "",
@@ -467,7 +535,10 @@ async function buildRouteIndex(config: DocsConfig): Promise<ResolvedRouteIndex>
     });
   } else if (Array.isArray(rootOpenApi)) {
     for (const openApiItem of rootOpenApi) {
-      if (typeof openApiItem !== "string" && (!openApiItem || typeof openApiItem !== "object")) {
+      if (
+        typeof openApiItem !== "string" &&
+        (!openApiItem || typeof openApiItem !== "object")
+      ) {
         continue;
       }
 
@@ -480,7 +551,11 @@ async function buildRouteIndex(config: DocsConfig): Promise<ResolvedRouteIndex>
   }
 
   if (homePath) {
-    addValidRoutePath(index, "/");
+    addValidRoutePath(index, prependBasePath("/"));
+  }
+
+  for (const hiddenPageRoute of config.hiddenPageRoutes ?? []) {
+    addHiddenPageRoute(index, hiddenPageRoute);
   }
 
   return index;
@@ -501,11 +576,24 @@ function buildInvalidInternalLinkError(args: {
   baseHref: string;
   currentDocFilePath: string | null;
   filePathCandidates: string[];
+  existingFilePathCandidates: string[];
 }): Error {
   const sourceFile = args.currentDocFilePath
     ? `${args.currentDocFilePath}.mdx`
     : "the current MDX file";
 
+  if (args.existingFilePathCandidates.length > 0) {
+    const existingFiles = args.existingFilePathCandidates
+      .map((candidate) => `"${candidate}.mdx"`)
+      .join(", ");
+
+    return new Error(
+      `[USER_ERROR]: Invalid internal link "${args.baseHref}" in ${sourceFile}. ` +
+        `The target file exists (${existingFiles}), but it is not a routable docs page. ` +
+        `Add it to docs.json navigation, set it as the home page, or link to it from the navbar or footer so it is included in the built site.`,
+    );
+  }
+
   const candidateHint =
     args.filePathCandidates.length > 0
       ? ` Tried file path candidates: ${args.filePathCandidates
@@ -515,7 +603,7 @@ function buildInvalidInternalLinkError(args: {
 
   return new Error(
     `[USER_ERROR]: Invalid internal link "${args.baseHref}" in ${sourceFile}. ` +
-      `Link must match an existing docs URL or resolve to a docs page file in navigation.${candidateHint}`,
+      `No matching docs page file was found. Create the target .mdx file or update the link.${candidateHint}`,
   );
 }
 
@@ -532,12 +620,29 @@ function resolveLinkToCanonicalHref(args: {
   }
 
   const normalizedBaseRoute = normalizeRoutePath(baseHref);
+  const normalizedBaseRouteWithBase = normalizeRoutePath(
+    baseHref.startsWith("/")
+      ? withBasePath(normalizedBaseRoute)
+      : prependBasePath(normalizedBaseRoute),
+  );
+  if (args.routeIndex.validRoutePaths.has(normalizedBaseRouteWithBase)) {
+    if (
+      baseHref.startsWith("/") &&
+      normalizedBaseRoute === normalizedBaseRouteWithBase
+    ) {
+      return null;
+    }
+
+    return `${normalizedBaseRouteWithBase}${parts.suffix}`;
+  }
+
   if (args.routeIndex.validRoutePaths.has(normalizedBaseRoute)) {
-    if (baseHref.startsWith("/")) {
+    const publicRoute = normalizeRoutePath(withBasePath(normalizedBaseRoute));
+    if (baseHref.startsWith("/") && normalizedBaseRoute === publicRoute) {
       return null;
     }
 
-    return `${normalizedBaseRoute}${parts.suffix}`;
+    return `${publicRoute}${parts.suffix}`;
   }
 
   const filePathCandidates = buildFilePathCandidates({
@@ -556,14 +661,19 @@ function resolveLinkToCanonicalHref(args: {
       );
     }
 
-    return `${canonicalHref}${parts.suffix}`;
+    return `${withBasePath(canonicalHref)}${parts.suffix}`;
   }
 
   if (shouldEnforceInternalRouteValidation(baseHref)) {
+    const existingFilePathCandidates = filePathCandidates.filter((filePath) =>
+      args.routeIndex.allDocsFilePaths.has(filePath),
+    );
+
     throw buildInvalidInternalLinkError({
       baseHref,
       currentDocFilePath: args.currentDocFilePath,
       filePathCandidates,
+      existingFilePathCandidates,
     });
   }
 

package/template/src/lib/pagefind.ts

@@ -1,4 +1,5 @@
 // Pagefind TypeScript types and wrapper
+import { getDocsBasePath, withBasePath } from "./base-path";
 import { resolveStaticAssetUrl } from "./static-asset-url";
 
 export interface PagefindSearchResult {
@@ -38,11 +39,11 @@ export interface PagefindSearchResponse {
 }
 
 export interface PagefindInstance {
-  options?: (options: { baseUrl?: string; basePath?: string }) => Promise<void>;
+  options?: (options: { baseUrl?: string }) => Promise<void>;
   init: () => Promise<void>;
   search: (
     query: string,
-    options?: { filters?: Record<string, string> }
+    options?: { filters?: Record<string, string> },
   ) => Promise<PagefindSearchResponse>;
   filters: () => Promise<Record<string, Record<string, number>>>;
   preload: (query: string) => Promise<void>;
@@ -54,6 +55,57 @@ function getPagefindScriptUrl(): string {
   return resolveStaticAssetUrl("/pagefind/pagefind.js");
 }
 
+function getPagefindResultBaseUrl(): string {
+  if (typeof window === "undefined") return "/";
+
+  return `${window.location.origin}${getDocsBasePath()}`;
+}
+
+function withBasePathForSearchResultUrl(url: string): string {
+  const basePath = getDocsBasePath();
+  if (!basePath || typeof window === "undefined") {
+    return withBasePath(url);
+  }
+
+  const isAbsoluteUrl =
+    /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url) || url.startsWith("//");
+  if (!isAbsoluteUrl) {
+    return withBasePath(url);
+  }
+
+  try {
+    const parsed = new URL(url, window.location.href);
+    if (
+      parsed.origin === window.location.origin &&
+      parsed.pathname !== basePath &&
+      !parsed.pathname.startsWith(`${basePath}/`)
+    ) {
+      const pathname = parsed.pathname.startsWith("/")
+        ? parsed.pathname
+        : `/${parsed.pathname}`;
+      parsed.pathname = `${basePath}${pathname}`;
+      return parsed.toString();
+    }
+  } catch {
+    // Fall through to normal relative URL handling.
+  }
+
+  return withBasePath(url);
+}
+
+function withBasePathForSearchResult(
+  data: PagefindResultData,
+): PagefindResultData {
+  return {
+    ...data,
+    url: withBasePathForSearchResultUrl(data.url),
+    sub_results: data.sub_results?.map((subResult) => ({
+      ...subResult,
+      url: withBasePathForSearchResultUrl(subResult.url),
+    })),
+  };
+}
+
 export async function getPagefind(): Promise<PagefindInstance | null> {
   if (pagefindInstance) return pagefindInstance;
 
@@ -62,17 +114,15 @@ export async function getPagefind(): Promise<PagefindInstance | null> {
     // This keeps Pagefind loading purely runtime and allows versioned query params.
     const importPagefind = new Function(
       "moduleUrl",
-      "return import(moduleUrl)"
+      "return import(moduleUrl)",
     ) as (moduleUrl: string) => Promise<PagefindInstance>;
 
     const pagefind = await importPagefind(getPagefindScriptUrl());
-    // Pagefind uses the script import location to derive result URL base.
-    // Since we import from the static host, force result links back to the
-    // current docs site origin while leaving asset fetches on static host.
+    // Pagefind uses the pagefind.js import URL to locate its index files.
+    // Only override result URLs; passing Pagefind's basePath would move
+    // pagefind-entry.json and chunk fetches back onto the docs origin.
     if (typeof pagefind.options === "function") {
-      const baseUrl =
-        typeof window !== "undefined" ? window.location.origin : "/";
-      await pagefind.options({ baseUrl });
+      await pagefind.options({ baseUrl: getPagefindResultBaseUrl() });
     }
     await pagefind.init();
     pagefindInstance = pagefind;
@@ -85,7 +135,7 @@ export async function getPagefind(): Promise<PagefindInstance | null> {
 
 export async function search(
   query: string,
-  limit: number = 8
+  limit: number = 8,
 ): Promise<PagefindResultData[]> {
   const pagefind = await getPagefind();
   if (!pagefind || !query.trim()) return [];
@@ -94,10 +144,8 @@ export async function search(
 
   // Load full data for top results
   const results = await Promise.all(
-    response.results.slice(0, limit).map((result) => result.data())
+    response.results.slice(0, limit).map((result) => result.data()),
   );
 
-  console.log("results", results);
-
-  return results;
+  return results.map(withBasePathForSearchResult);
 }