@stainless-api/docs-search 0.1.0-beta.1

package/dist/algolia-BOY-OcxU.js

@@ -0,0 +1,83 @@
+import { n as generateIndex, t as generateChatIndex } from "./indexer-DBU0POrK.js";
+import { i as SearchableAttributesProse, n as SearchableAttributes, r as SearchableAttributesChat } from "./types-BhJLoaNF.js";
+import { searchClient } from "@algolia/client-search";
+
+//#region src/providers/algolia.ts
+async function buildIndex(appId, indexName, writeKey, spec, renderMarkdown) {
+	if (!appId || !indexName || !writeKey) return;
+	const objects = Array.from(generateIndex(spec, renderMarkdown));
+	const client = searchClient(appId, writeKey);
+	await client.setSettings({
+		indexName,
+		indexSettings: {
+			highlightPreTag: "<mark>",
+			highlightPostTag: "</mark>",
+			customRanking: ["asc(priority)"],
+			attributesForFaceting: ["language", "kind"],
+			searchableAttributes: [...SearchableAttributes]
+		}
+	});
+	await client.replaceAllObjects({
+		indexName,
+		objects
+	});
+}
+async function buildChatIndex(appId, indexName, writeKey, spec) {
+	if (!appId || !indexName || !writeKey) return;
+	const objects = Array.from(generateChatIndex(spec));
+	const client = searchClient(appId, writeKey);
+	await client.setSettings({
+		indexName,
+		indexSettings: {
+			attributesForFaceting: ["language"],
+			attributeForDistinct: "stainlessPath",
+			searchableAttributes: SearchableAttributesChat
+		}
+	});
+	await client.replaceAllObjects({
+		indexName,
+		objects
+	});
+}
+async function buildProseIndex(appId, indexName, writeKey, objects) {
+	if (!appId || !indexName || !writeKey) return;
+	const client = searchClient(appId, writeKey);
+	await client.setSettings({
+		indexName,
+		indexSettings: { searchableAttributes: SearchableAttributesProse }
+	});
+	await client.replaceAllObjects({
+		indexName,
+		objects
+	});
+}
+async function search({ settings: { appId, indexName, searchKey }, params: { query, language, kind } }) {
+	const client = searchClient(appId, searchKey);
+	const filters = language ? `language:${language}` : void 0;
+	const facetFilters = kind ? [`kind:${kind}`] : void 0;
+	const { results } = await client.search({ requests: [{
+		query,
+		indexName,
+		filters,
+		hitsPerPage: 5,
+		facets: ["kind"]
+	}, {
+		query,
+		indexName,
+		filters,
+		facetFilters,
+		facets: ["kind"],
+		hitsPerPage: 50
+	}] });
+	if ("hits" in results[0] && "hits" in results[1]) {
+		const [{ nbHits, facets }, { hits }] = results;
+		return {
+			hits,
+			nbHits: nbHits ?? 0,
+			facets
+		};
+	}
+}
+
+//#endregion
+export { search as i, buildIndex as n, buildProseIndex as r, buildChatIndex as t };

package/dist/context-CBTWkDal.js

@@ -0,0 +1,32 @@
+import { i as search } from "./algolia-BOY-OcxU.js";
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/context.tsx
+function createStrictContext(displayName) {
+	const Context = React.createContext(null);
+	Context.displayName = displayName;
+	function useStrictContext() {
+		const context = React.useContext(Context);
+		if (context === null) throw new Error(`use${displayName} must be used within a ${displayName}Provider`);
+		return context;
+	}
+	return [Context.Provider, useStrictContext];
+}
+const [Provider, useSearchContext] = createStrictContext("SearchContext");
+function useSearch() {
+	const { settings } = useSearchContext();
+	return (params) => search({
+		settings,
+		params
+	});
+}
+function SearchProvider({ children, ...props }) {
+	return /* @__PURE__ */ jsx(Provider, {
+		value: props,
+		children
+	});
+}
+
+//#endregion
+export { useSearch as n, useSearchContext as r, SearchProvider as t };

package/dist/context.d.ts

@@ -0,0 +1,21 @@
+import { f as ResultType, g as SearchSettings, h as SearchParams } from "./types-Gg968wOz.js";
+import * as React from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/context.d.ts
+type SearchContextType = {
+  settings: SearchSettings;
+  onSelect?: (stainlessPath: string) => void;
+  pageFind?: string;
+};
+declare const useSearchContext: () => SearchContextType;
+declare function useSearch(): (params: SearchParams) => Promise<ResultType | undefined>;
+type SearchProviderProps = SearchContextType & {
+  children: React.ReactNode;
+};
+declare function SearchProvider({
+  children,
+  ...props
+}: SearchProviderProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { SearchContextType, SearchProvider, SearchProviderProps, useSearch, useSearchContext };

package/dist/context.js

@@ -0,0 +1,5 @@
+import "./indexer-DBU0POrK.js";
+import "./algolia-BOY-OcxU.js";
+import { n as useSearch, r as useSearchContext, t as SearchProvider } from "./context-CBTWkDal.js";
+
+export { SearchProvider, useSearch, useSearchContext };

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { l as QueryKindsType, u as ResultData } from "./types-Gg968wOz.js";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/form.d.ts
+declare function SearchForm(): react_jsx_runtime0.JSX.Element;
+type SearchFilterProps = {
+  results: ResultData;
+  filterKind: QueryKindsType;
+  onChange: (filterKind: QueryKindsType) => void;
+};
+declare function SearchFilter({
+  results,
+  filterKind,
+  onChange
+}: SearchFilterProps): react_jsx_runtime0.JSX.Element;
+type SearchModalProps = {
+  id?: string;
+  open?: boolean;
+};
+declare function SearchModal({
+  id,
+  open: isOpen
+}: SearchModalProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { SearchFilter, SearchFilterProps, SearchForm, SearchModal, SearchModalProps };

package/dist/index.js

@@ -0,0 +1,328 @@
+import "./indexer-DBU0POrK.js";
+import { t as QueryKinds } from "./types-BhJLoaNF.js";
+import "./algolia-BOY-OcxU.js";
+import { n as useSearch, r as useSearchContext } from "./context-CBTWkDal.js";
+import { t as guideSearch } from "./pagefind-Dcn-gjDe.js";
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { BookOpenText, Box, Code, Folder, Search, Wrench, X } from "lucide-react";
+import { useLanguage } from "@stainless-api/docs-ui/contexts";
+import { useComponents } from "@stainless-api/docs-ui/contexts/use-components";
+import style from "@stainless-api/docs-ui/style";
+
+//#region src/results.tsx
+const QueryKindDisplay = {
+	all: {
+		name: "Results",
+		icon: Search
+	},
+	resource: {
+		name: "Resources",
+		icon: Folder
+	},
+	http_method: {
+		name: "Methods",
+		icon: Box
+	},
+	model: {
+		name: "Types",
+		icon: Code
+	},
+	property: {
+		name: "Properties",
+		icon: Wrench
+	},
+	guide: {
+		name: "Guide",
+		icon: BookOpenText
+	}
+};
+function Highlight({ result, name }) {
+	const value = result._highlightResult[name]?.value;
+	if (value) return /* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: value } });
+}
+function SearchResultBreadcrumb({ result }) {
+	const Docs = useComponents();
+	const Icon = QueryKindDisplay[result.kind].icon;
+	const items = result.crumbs?.map((crumb) => /* @__PURE__ */ jsx("span", {
+		className: style.SearchBreadcrumbItem,
+		children: crumb
+	}, crumb));
+	return /* @__PURE__ */ jsxs("div", {
+		className: style.SearchBreadcrumb,
+		children: [/* @__PURE__ */ jsx(Icon, {
+			className: style.Icon,
+			size: 14
+		}), Array.isArray(result.crumbs) && /* @__PURE__ */ jsx(Docs.Join, {
+			items,
+			children: /* @__PURE__ */ jsx("span", {
+				className: style.SearchBreadcrumbDivider,
+				children: "›"
+			})
+		})]
+	});
+}
+function SearchResult({ result }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: style.SearchResult,
+		"data-stldocs-search-result": result.kind,
+		children: [/* @__PURE__ */ jsx(SearchResultBreadcrumb, { result }), /* @__PURE__ */ jsx(SearchResultContent, { result })]
+	});
+}
+function GuideResult({ result }) {
+	const Docs = useComponents();
+	const Icon = QueryKindDisplay["guide"].icon;
+	const path = result.data.url.slice(1, -1).split("/").map((crumb) => /* @__PURE__ */ jsx("span", {
+		className: style.SearchBreadcrumbItem,
+		children: crumb
+	}, crumb));
+	const crumbs = path.length > 1 ? path : [/* @__PURE__ */ jsx("span", {
+		className: style.SearchBreadcrumbItem,
+		children: "Overview"
+	}, "overview")];
+	return /* @__PURE__ */ jsxs("div", {
+		className: style.SearchResult,
+		"data-stldocs-search-result": "guide",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: style.SearchBreadcrumb,
+				children: [/* @__PURE__ */ jsx(Icon, {
+					className: style.Icon,
+					size: 14
+				}), /* @__PURE__ */ jsx(Docs.Join, {
+					items: crumbs,
+					children: /* @__PURE__ */ jsx("span", {
+						className: style.SearchBreadcrumbDivider,
+						children: "›"
+					})
+				})]
+			}),
+			/* @__PURE__ */ jsx("h3", {
+				className: style.SearchResultGuideTitle,
+				children: result.data.meta.title
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: style.SearchResultGuideExcerpt,
+				dangerouslySetInnerHTML: { __html: result.data.excerpt }
+			})
+		]
+	});
+}
+function SearchResultContent({ result }) {
+	const Docs = useComponents();
+	const language = useLanguage();
+	switch (result.kind) {
+		case "http_method": return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Docs.MethodHeader, {
+			level: "h5",
+			title: /* @__PURE__ */ jsx(Highlight, {
+				result,
+				name: result.summary ? "summary" : "title"
+			}),
+			signature: result["qualified"] && /* @__PURE__ */ jsx(Highlight, {
+				result,
+				name: "qualified"
+			}),
+			children: /* @__PURE__ */ jsx(Docs.MethodRoute, {
+				httpMethod: result.httpMethod,
+				endpoint: /* @__PURE__ */ jsx(Highlight, {
+					result,
+					name: "endpoint"
+				})
+			})
+		}), /* @__PURE__ */ jsx("div", {
+			className: `${style.MethodDescription} ${style.Content}`,
+			children: /* @__PURE__ */ jsx(Highlight, {
+				result,
+				name: "description"
+			})
+		})] });
+		case "model": {
+			const properties = result.children?.map((child, index) => /* @__PURE__ */ jsx("span", {
+				className: style.TextIdentifier,
+				children: child
+			}, index)) ?? [];
+			return /* @__PURE__ */ jsxs("div", {
+				className: style.Property,
+				"data-stldocs-language": language,
+				children: [/* @__PURE__ */ jsx("div", {
+					className: style.PropertyHeader,
+					children: /* @__PURE__ */ jsx("span", {
+						className: style.PropertyName,
+						children: /* @__PURE__ */ jsx(Highlight, {
+							result,
+							name: result.title ? "title" : "name"
+						})
+					})
+				}), /* @__PURE__ */ jsxs("span", {
+					className: style.PropertyDeclaration,
+					children: [
+						/* @__PURE__ */ jsx(Highlight, {
+							result,
+							name: "ident"
+						}),
+						":",
+						" ",
+						/* @__PURE__ */ jsx(Docs.Join, {
+							items: properties,
+							limit: 3,
+							children: /* @__PURE__ */ jsx("span", {
+								className: style.TextPunctuation,
+								children: ", "
+							})
+						})
+					]
+				})]
+			});
+		}
+		case "resource": return /* @__PURE__ */ jsxs("div", {
+			className: style.SearchResultResourceInfo,
+			children: [/* @__PURE__ */ jsx("span", {
+				className: style.SearchResultResourceTitle,
+				children: /* @__PURE__ */ jsx(Highlight, {
+					result,
+					name: "title"
+				})
+			}), /* @__PURE__ */ jsx("span", {
+				className: style.SearchResultResourcePath,
+				children: /* @__PURE__ */ jsx(Highlight, {
+					result,
+					name: "QualifiedName"
+				})
+			})]
+		});
+		case "property": return /* @__PURE__ */ jsxs("div", {
+			className: style.Property,
+			"data-stldocs-language": language,
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: style.PropertyHeader,
+				children: [/* @__PURE__ */ jsx("span", {
+					className: style.PropertyName,
+					children: /* @__PURE__ */ jsx(Highlight, {
+						result,
+						name: "name"
+					})
+				}), /* @__PURE__ */ jsx("span", {
+					className: style.PropertyTypeName,
+					children: /* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: result.type ?? "" } })
+				})]
+			}), result.docstring && /* @__PURE__ */ jsx("span", {
+				className: style.PropertyDescription,
+				children: /* @__PURE__ */ jsx(Highlight, {
+					result,
+					name: "docstring"
+				})
+			})]
+		});
+	}
+}
+
+//#endregion
+//#region src/form.tsx
+function SearchForm() {
+	const Docs = useComponents();
+	const search = useSearch();
+	const language = useLanguage();
+	const { onSelect, pageFind } = useSearchContext();
+	const [results, setResults] = React.useState(null);
+	const [filterKind, setFilterKind] = React.useState("all");
+	const [searchQuery, setSearchQuery] = React.useState("");
+	const inputRef = React.useRef(null);
+	async function performSearch() {
+		const guideLimit = filterKind === "guide" ? 25 : 5;
+		const kind = ["all", "guide"].includes(filterKind) ? void 0 : filterKind;
+		const [guideResults, apiResults] = await Promise.all([pageFind ? guideSearch(pageFind, searchQuery, guideLimit) : [], search({
+			query: searchQuery,
+			kind,
+			language
+		})]);
+		setResults({
+			items: filterKind === "guide" ? guideResults : filterKind === "all" ? [...guideResults.slice(0, 5), ...apiResults?.hits ?? []] : apiResults?.hits ?? [],
+			counts: {
+				...apiResults?.facets?.["kind"],
+				guide: guideResults.length,
+				all: apiResults?.nbHits
+			}
+		});
+	}
+	function clearInput() {
+		setSearchQuery("");
+		inputRef?.current?.focus();
+	}
+	React.useEffect(() => void performSearch(), [
+		searchQuery,
+		filterKind,
+		language
+	]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: style.SearchForm,
+		children: [
+			/* @__PURE__ */ jsx(Docs.Input, {
+				ref: inputRef,
+				autoFocus: true,
+				onChange: (ev) => setSearchQuery(ev.target.value),
+				left: /* @__PURE__ */ jsx(Search, {
+					size: 16,
+					className: style.Icon
+				}),
+				right: searchQuery && /* @__PURE__ */ jsx(X, {
+					cursor: "pointer",
+					onClick: () => clearInput(),
+					size: 16,
+					className: style.Icon
+				}),
+				value: searchQuery,
+				placeholder: "Search"
+			}),
+			/* @__PURE__ */ jsx(SearchFilter, {
+				results,
+				filterKind,
+				onChange: (filterKind$1) => setFilterKind(filterKind$1)
+			}),
+			/* @__PURE__ */ jsx(Docs.ListView, {
+				items: results?.items ?? [],
+				itemDelegate: (item) => "kind" in item ? /* @__PURE__ */ jsx(SearchResult, { result: item }) : /* @__PURE__ */ jsx(GuideResult, { result: item }),
+				onSelectListItem: (item) => onSelect?.(item["data"]?.["url"] ?? item["stainlessPath"])
+			})
+		]
+	});
+}
+function SearchFilter({ results, filterKind, onChange }) {
+	const Docs = useComponents();
+	const { pageFind } = useSearchContext();
+	const toggles = pageFind ? QueryKinds : QueryKinds.slice(0, -1);
+	return /* @__PURE__ */ jsx("div", {
+		className: style.SearchFilter,
+		children: toggles.map((kind, index) => /* @__PURE__ */ jsxs(Docs.ToggleButton, {
+			selected: filterKind === kind,
+			onClick: () => onChange?.(kind),
+			children: [
+				React.createElement(QueryKindDisplay[kind].icon, {
+					size: 16,
+					className: style.Icon
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: style.SearchFilterLabel,
+					children: QueryKindDisplay[kind].name
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: style.SearchFilterCount,
+					children: results?.counts?.[kind] ?? 0
+				})
+			]
+		}, index))
+	});
+}
+function SearchModal({ id, open: isOpen }) {
+	const [open, setOpen] = React.useState(isOpen ?? false);
+	return /* @__PURE__ */ jsx("div", {
+		id,
+		onToggle: (ev) => setOpen(ev.newState === "open"),
+		className: style.SearchModal,
+		popover: "auto",
+		"data-stldocs-modal-open": open,
+		children: open && /* @__PURE__ */ jsx(SearchForm, {})
+	});
+}
+
+//#endregion
+export { SearchFilter, SearchForm, SearchModal };

package/dist/indexer-DBU0POrK.js

@@ -0,0 +1,181 @@
+import { Languages, generateRoute, parseStainlessPath, walkTree } from "@stainless-api/docs-ui/routing";
+import { printer, renderMarkdown } from "@stainless-api/docs-ui/markdown";
+
+//#region src/indexer.ts
+function getResourceNames(resourceIds, topResources) {
+	let element = void 0;
+	let resources = topResources;
+	const resourceName = [];
+	for (const resource of resourceIds) {
+		element = resources?.[resource];
+		if (!element) break;
+		resourceName.push(element.title);
+		resources = element?.subresources;
+	}
+	return resourceName;
+}
+function chunkByLines(content, maxSize = 6e4) {
+	if (Buffer.byteLength(content, "utf8") < maxSize) return [content];
+	const lines = content.split("\n");
+	const chunks = [];
+	let currentChunk = [];
+	let currentSize = 0;
+	for (const line of lines) {
+		const lineSize = Buffer.byteLength(line + "\n", "utf8");
+		if (currentSize + lineSize > maxSize) {
+			chunks.push(currentChunk.join("\n"));
+			currentChunk = [];
+			currentSize = 0;
+		}
+		currentChunk.push(line);
+		currentSize += lineSize;
+	}
+	if (currentChunk.length > 0) chunks.push(currentChunk.join("\n"));
+	return chunks;
+}
+function* generateChatIndex(spec) {
+	for (const [language, readme] of Object.entries(spec.readme)) {
+		const chunks = chunkByLines(readme);
+		for (const chunk of chunks) yield {
+			language,
+			title: "Overview",
+			content: chunk,
+			url: `docs://BASE_PATH/${language}`
+		};
+	}
+	for (const { data } of walkTree(spec)) {
+		if (data.kind !== "http_method") continue;
+		const { title, name, stainlessPath, httpMethod, summary, description } = data;
+		const endpoint = data.endpoint.slice(httpMethod.length).trim();
+		for (const language of Languages) {
+			const decl = spec.decls[language]?.[stainlessPath];
+			if (!decl) continue;
+			const chunks = chunkByLines(renderMarkdown({
+				spec,
+				language,
+				options: { includeModelProperties: true }
+			}, data));
+			for (const chunk of chunks) yield {
+				language,
+				title,
+				name,
+				endpoint,
+				httpMethod,
+				summary,
+				description,
+				stainlessPath,
+				qualified: "qualified" in decl ? decl["qualified"] : void 0,
+				ident: "ident" in decl ? decl["ident"] : void 0,
+				content: chunk,
+				url: generateRoute("docs://BASE_PATH", language, stainlessPath)
+			};
+		}
+	}
+}
+function* generateIndex(spec, renderMarkdownFn, includeTypes) {
+	const parentCrumbs = {};
+	for (const { data } of walkTree(spec, true)) {
+		const { kind, name, title, stainlessPath } = data;
+		const common = {
+			name,
+			title,
+			stainlessPath
+		};
+		const crumbs = getResourceNames(parseStainlessPath(stainlessPath).resource, spec.resources);
+		switch (kind) {
+			case "resource":
+				for (const language of Languages) {
+					if (!data[language]) continue;
+					parentCrumbs[stainlessPath] = crumbs;
+					const { Name, QualifiedName } = data[language];
+					yield {
+						kind,
+						crumbs,
+						language,
+						Name,
+						QualifiedName,
+						priority: 0,
+						...common
+					};
+				}
+				break;
+			case "http_method": {
+				const { summary, endpoint, httpMethod } = data;
+				for (const language of Languages) {
+					const found = spec.decls[language]?.[stainlessPath];
+					if (!found) continue;
+					parentCrumbs[stainlessPath] = [...crumbs, title];
+					const qualified = "qualified" in found ? found["qualified"] : void 0;
+					const ident = qualified?.split(".")?.at(-1);
+					yield {
+						kind,
+						crumbs: [...crumbs, title],
+						ident,
+						qualified,
+						language,
+						description: data.description ? renderMarkdownFn?.(data.description) ?? data.description : void 0,
+						endpoint: endpoint.slice(httpMethod.length).trim(),
+						httpMethod,
+						summary,
+						priority: 0,
+						...common
+					};
+				}
+				break;
+			}
+			case "model": for (const language of Languages) {
+				if (!spec.decls[language]) continue;
+				parentCrumbs[stainlessPath] = [...crumbs, title];
+				const schema = spec.decls[language]?.[`${stainlessPath} > (schema)`];
+				const children = (schema && "children" in schema ? schema?.["children"] : void 0)?.map((childPath) => {
+					const child = spec.decls?.[language]?.[childPath];
+					return child?.["ident"] ?? child?.["name"] ?? child?.["key"] ?? child?.["type"]?.["literal"]?.["value"] ?? child?.["type"]?.["literal"] ?? child?.["type"]?.["value"];
+				})?.filter((child) => child) ?? [];
+				yield {
+					kind,
+					crumbs: [...crumbs, title],
+					children,
+					language,
+					priority: 2,
+					ident: schema && "ident" in schema ? schema?.["ident"] : void 0,
+					...common
+				};
+			}
+		}
+	}
+	for (const language of Languages) {
+		const decls = spec.decls?.[language];
+		if (!decls) continue;
+		for (const decl of Object.values(decls)) switch (decl.kind) {
+			case "JavaDeclProperty":
+			case "GoDeclProperty":
+			case "PythonDeclProperty":
+			case "RubyDeclProperty":
+			case "HttpDeclProperty":
+			case "TSDeclProperty":
+				{
+					const parsedPath = parseStainlessPath(decl.stainlessPath);
+					const type = includeTypes === false ? void 0 : printer.typeName(language, decl.type);
+					const name = decl["ident"] ?? decl["name"] ?? decl["key"];
+					const parent = parentCrumbs[parsedPath.routable];
+					if (parent === void 0) continue;
+					const matches = decl.stainlessPath.matchAll(/\((property|params|param)\) ([^\s]+)/g);
+					const props = Array.from(matches).map((p) => p[2]).filter((p) => p !== void 0);
+					yield {
+						kind: "property",
+						name,
+						stainlessPath: decl.stainlessPath,
+						crumbs: [...parent, ...props],
+						docstring: decl.docstring ? renderMarkdownFn?.(decl.docstring) ?? decl.docstring : void 0,
+						type,
+						language,
+						priority: 3
+					};
+				}
+				break;
+		}
+	}
+}
+
+//#endregion
+export { generateIndex as n, generateChatIndex as t };

package/dist/mcp.d.ts

@@ -0,0 +1,13 @@
+import { n as IndexEntry, r as IndexMethod } from "./types-Gg968wOz.js";
+import { DocsLanguage } from "@stainless-api/docs-ui/routing";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/indexer.d.ts
+
+declare function generateIndex(spec: SDKJSON.Spec, renderMarkdownFn?: (_: string) => string | null, includeTypes?: boolean): Generator<IndexEntry>;
+//#endregion
+//#region src/mcp.d.ts
+type Item = IndexEntry & IndexMethod;
+declare function render(spec: SDKJSON.Spec, language: DocsLanguage, items: Item[], includeModelProperties: boolean): any;
+//#endregion
+export { generateIndex, render };

package/dist/mcp.js

@@ -0,0 +1,36 @@
+import { n as generateIndex } from "./indexer-DBU0POrK.js";
+import { parseStainlessPath } from "@stainless-api/docs-ui/routing";
+import { renderMarkdown } from "@stainless-api/docs-ui/markdown";
+import { getResourceFromSpec } from "@stainless-api/docs-ui/utils";
+
+//#region src/mcp.ts
+function consolidate(results) {
+	const resources = /* @__PURE__ */ new Set();
+	const methods = /* @__PURE__ */ new Set();
+	for (const entry of results) {
+		const parsed = parseStainlessPath(entry.stainlessPath);
+		if (parsed.method) methods.add(parsed.routable);
+		else resources.add(parsed.routable);
+	}
+	const filtered = Array.from(methods).filter((path) => !resources.has(path.split(" >").at(0)));
+	return [...resources, ...filtered];
+}
+function render(spec, language, items, includeModelProperties) {
+	const env = {
+		spec,
+		language,
+		options: {
+			renderNestedResources: false,
+			includeModelProperties
+		}
+	};
+	const output = consolidate(items).map((entry) => {
+		const parsed = parseStainlessPath(entry);
+		const resource = getResourceFromSpec(parsed.resource, spec);
+		return [entry, renderMarkdown(env, parsed.method ? resource.methods[parsed.method] : resource)];
+	});
+	return Object.fromEntries(output);
+}
+
+//#endregion
+export { generateIndex, render };

package/dist/pagefind-Dcn-gjDe.js

@@ -0,0 +1,15 @@
+//#region src/providers/pagefind.ts
+async function loadPagefind(path) {
+	return await import(new URL(path, import.meta.url).href);
+}
+async function guideSearch(loadPath, query, limit) {
+	const response = await (await loadPagefind(loadPath)).search(query);
+	const items = limit ? response.results.slice(0, limit) : response.results;
+	return Promise.all(items.map((result) => result.data().then((data) => ({
+		...result,
+		data
+	}))));
+}
+
+//#endregion
+export { guideSearch as t };

package/dist/providers/algolia.d.ts

@@ -0,0 +1,24 @@
+import { f as ResultType, g as SearchSettings, h as SearchParams, s as ProseIndexEntry } from "../types-Gg968wOz.js";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/providers/algolia.d.ts
+declare function buildIndex(appId: string, indexName: string, writeKey: string, spec: SDKJSON.Spec, renderMarkdown: (_: string) => string | null): Promise<void>;
+declare function buildChatIndex(appId: string, indexName: string, writeKey: string, spec: SDKJSON.Spec): Promise<void>;
+declare function buildProseIndex(appId: string, indexName: string, writeKey: string, objects: ProseIndexEntry[]): Promise<void>;
+declare function search({
+  settings: {
+    appId,
+    indexName,
+    searchKey
+  },
+  params: {
+    query,
+    language,
+    kind
+  }
+}: {
+  params: SearchParams;
+  settings: SearchSettings;
+}): Promise<ResultType | undefined>;
+//#endregion
+export { buildChatIndex, buildIndex, buildProseIndex, search };

package/dist/providers/algolia.js

@@ -0,0 +1,4 @@
+import "../indexer-DBU0POrK.js";
+import { i as search, n as buildIndex, r as buildProseIndex, t as buildChatIndex } from "../algolia-BOY-OcxU.js";
+
+export { buildChatIndex, buildIndex, buildProseIndex, search };

package/dist/providers/fuse.d.ts

@@ -0,0 +1,18 @@
+import { n as IndexEntry } from "../types-Gg968wOz.js";
+import { DocsLanguage } from "@stainless-api/docs-ui/routing";
+import * as fuse_js0 from "fuse.js";
+import { FuseIndex } from "fuse.js";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/providers/fuse.d.ts
+type FuseIndexData = {
+  content: IndexEntry[];
+  index: FuseIndex<IndexEntry>;
+};
+declare function buildIndex(spec: SDKJSON.Spec, language?: DocsLanguage): FuseIndexData;
+declare function search({
+  content,
+  index
+}: FuseIndexData, query: string, limit?: number): fuse_js0.FuseResult<IndexEntry>[];
+//#endregion
+export { FuseIndexData, buildIndex, search };

package/dist/providers/fuse.js

@@ -0,0 +1,19 @@
+import { n as generateIndex } from "../indexer-DBU0POrK.js";
+import { n as SearchableAttributes } from "../types-BhJLoaNF.js";
+import Fuse from "fuse.js";
+
+//#region src/providers/fuse.ts
+function buildIndex(spec, language) {
+	const idx = Array.from(generateIndex(spec, void 0, false));
+	const content = language ? idx.filter((entry) => entry.language === language) : idx;
+	return {
+		content,
+		index: Fuse.createIndex([...SearchableAttributes], content)
+	};
+}
+function search({ content, index }, query, limit = 100) {
+	return new Fuse(content, { keys: [...SearchableAttributes] }, index).search(query).slice(0, limit);
+}
+
+//#endregion
+export { buildIndex, search };

package/dist/providers/pagefind.d.ts

@@ -0,0 +1,6 @@
+import { t as GuideResultType } from "../types-Gg968wOz.js";
+
+//#region src/providers/pagefind.d.ts
+declare function guideSearch(loadPath: string, query: string, limit?: number): Promise<GuideResultType[]>;
+//#endregion
+export { guideSearch };

package/dist/providers/pagefind.js

@@ -0,0 +1,3 @@
+import { t as guideSearch } from "../pagefind-Dcn-gjDe.js";
+
+export { guideSearch };

package/dist/providers/walker.d.ts

@@ -0,0 +1,9 @@
+import { n as IndexEntry } from "../types-Gg968wOz.js";
+import { DocsLanguage } from "@stainless-api/docs-ui/routing";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/providers/walker.d.ts
+declare function buildIndex(spec: SDKJSON.Spec): Generator<IndexEntry, any, any>;
+declare function search(index: Generator<IndexEntry>, language: DocsLanguage, query: string, limit?: number): IndexEntry[];
+//#endregion
+export { buildIndex, search };

package/dist/providers/walker.js

@@ -0,0 +1,23 @@
+import { n as generateIndex } from "../indexer-DBU0POrK.js";
+import { n as SearchableAttributes } from "../types-BhJLoaNF.js";
+
+//#region src/providers/walker.ts
+function buildIndex(spec) {
+	return generateIndex(spec, void 0, false);
+}
+function* findEntryInIndex(index, language, query) {
+	for (const entry of index) {
+		if (entry.language !== language) continue;
+		for (const attr of SearchableAttributes) {
+			const attr_ = attr in entry ? attr : null;
+			if (attr_ && entry[attr_] && typeof entry[attr_] === "string" && entry[attr_].includes(query)) yield entry;
+		}
+	}
+}
+function search(index, language, query, limit = 100) {
+	const results = findEntryInIndex(index, language, query);
+	return Array.from(results).sort((a, b) => a.priority - b.priority).slice(0, limit);
+}
+
+//#endregion
+export { buildIndex, search };

package/dist/types-BhJLoaNF.js

@@ -0,0 +1,35 @@
+//#region src/types.ts
+const QueryKinds = [
+	"all",
+	"resource",
+	"http_method",
+	"model",
+	"property",
+	"guide"
+];
+const SearchableAttributes = [
+	"name",
+	"title",
+	"ident",
+	"Name",
+	"qualified",
+	"QualifiedName",
+	"endpoint",
+	"summary",
+	"description",
+	"docstring"
+];
+const SearchableAttributesChat = [
+	"title",
+	"name",
+	"endpoint",
+	"summary",
+	"description",
+	"qualified",
+	"ident",
+	"content"
+];
+const SearchableAttributesProse = ["content"];
+
+//#endregion
+export { SearchableAttributesProse as i, SearchableAttributes as n, SearchableAttributesChat as r, QueryKinds as t };

package/dist/types-Gg968wOz.d.ts

@@ -0,0 +1,91 @@
+import { DocsLanguage } from "@stainless-api/docs-ui/routing";
+import * as SDKJSON from "@stainless/sdk-json";
+
+//#region src/types.d.ts
+type SearchSettings = {
+  appId: string;
+  searchKey: string;
+  indexName: string;
+  assistant?: string;
+};
+type SearchParams = {
+  query: string;
+  language?: DocsLanguage | null;
+  kind?: QueryKindsType | null;
+};
+declare const QueryKinds: readonly ["all", "resource", "http_method", "model", "property", "guide"];
+type QueryKindsType = (typeof QueryKinds)[number];
+type IndexModel = {
+  kind: 'model';
+  title: string;
+  children?: string[];
+  ident?: string;
+};
+type IndexProperty = {
+  kind: 'property';
+  docstring?: string;
+  type?: string;
+};
+type IndexResource = {
+  kind: 'resource';
+  title: string;
+  Name: string;
+  QualifiedName: string;
+};
+type IndexMethod = Pick<SDKJSON.Method, 'kind' | 'summary' | 'description' | 'endpoint' | 'httpMethod'> & {
+  title: string;
+  qualified?: string;
+  ident?: string;
+};
+declare const SearchableAttributes: readonly ["name", "title", "ident", "Name", "qualified", "QualifiedName", "endpoint", "summary", "description", "docstring"];
+declare const SearchableAttributesChat: string[];
+declare const SearchableAttributesProse: string[];
+type SearchAttributeNames = (typeof SearchableAttributes)[number];
+type RoutableJsonNode = SDKJSON.Method | SDKJSON.Model | SDKJSON.Resource;
+type IndexEntry = Pick<RoutableJsonNode, 'name' | 'stainlessPath'> & (IndexProperty | IndexModel | IndexResource | IndexMethod) & {
+  language: DocsLanguage;
+  priority: number;
+  crumbs: string[];
+};
+type ResultRecordType = IndexEntry & {
+  objectID: string;
+  _highlightResult: Record<SearchAttributeNames, {
+    value: string;
+  }>;
+};
+type ResultType = {
+  hits: ResultRecordType[];
+  facets?: Record<string, Record<string, number>>;
+  nbHits: number;
+};
+type GuideResultType = {
+  id: string;
+  score: number;
+  words: number[];
+  data: {
+    excerpt: string;
+    url: string;
+    word_count: number;
+    meta: {
+      title: string;
+    };
+    sub_results: {
+      url: string;
+      title: string;
+      excerpt: string;
+    }[];
+  };
+};
+type ResultData = {
+  items: Array<ResultRecordType | GuideResultType>;
+  counts: Partial<Record<QueryKindsType, number>>;
+};
+type ProseIndexEntry = {
+  id?: string;
+  tag: string;
+  content: string;
+  source?: string;
+  [additional: string]: unknown;
+};
+//#endregion
+export { SearchableAttributes as _, IndexProperty as a, QueryKinds as c, ResultRecordType as d, ResultType as f, SearchSettings as g, SearchParams as h, IndexModel as i, QueryKindsType as l, SearchAttributeNames as m, IndexEntry as n, IndexResource as o, RoutableJsonNode as p, IndexMethod as r, ProseIndexEntry as s, GuideResultType as t, ResultData as u, SearchableAttributesChat as v, SearchableAttributesProse as y };

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { _ as SearchableAttributes, a as IndexProperty, c as QueryKinds, d as ResultRecordType, f as ResultType, g as SearchSettings, h as SearchParams, i as IndexModel, l as QueryKindsType, m as SearchAttributeNames, n as IndexEntry, o as IndexResource, p as RoutableJsonNode, r as IndexMethod, s as ProseIndexEntry, t as GuideResultType, u as ResultData, v as SearchableAttributesChat, y as SearchableAttributesProse } from "./types-Gg968wOz.js";
+export { GuideResultType, IndexEntry, IndexMethod, IndexModel, IndexProperty, IndexResource, ProseIndexEntry, QueryKinds, QueryKindsType, ResultData, ResultRecordType, ResultType, RoutableJsonNode, SearchAttributeNames, SearchParams, SearchSettings, SearchableAttributes, SearchableAttributesChat, SearchableAttributesProse };

package/dist/types.js

@@ -0,0 +1,3 @@
+import { i as SearchableAttributesProse, n as SearchableAttributes, r as SearchableAttributesChat, t as QueryKinds } from "./types-BhJLoaNF.js";
+
+export { QueryKinds, SearchableAttributes, SearchableAttributesChat, SearchableAttributesProse };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@stainless-api/docs-search",
+  "version": "0.1.0-beta.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "dependencies": {
+    "@algolia/client-search": "^5.25.0",
+    "@markdoc/markdoc": "^0.5.4",
+    "cheerio": "^1.1.2",
+    "fuse.js": "^7.1.0",
+    "htmlparser2": "^10.0.0",
+    "lucide-react": "^0.561.0",
+    "@stainless-api/docs-ui": "0.1.0-beta.49"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "@types/react": "19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "dotenv": "17.2.3",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "tsdown": "^0.17.3",
+    "typescript": "5.9.3",
+    "@stainless/eslint-config": "0.1.0-beta.0",
+    "@stainless/sdk-json": "^0.1.0-beta.2"
+  },
+  "exports": {
+    ".": {
+      "default": "./dist/index.js"
+    },
+    "./context": {
+      "default": "./dist/context.js"
+    },
+    "./mcp": {
+      "default": "./dist/mcp.js"
+    },
+    "./types": {
+      "default": "./dist/types.js"
+    },
+    "./providers/*": {
+      "default": "./dist/providers/*.js"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist",
+    "lint": "eslint .",
+    "check:types": "tsc --noEmit"
+  }
+}