@salesforce/ui-bundle-template-app-react-template-b2e 11.55.0 → 11.56.0

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/hooks/useSearch.ts

@@ -23,7 +23,7 @@ import {
 import type { SortState } from "../utils/sortUtils";
 import { debounce } from "../utils/debounce";
 import type {
-	SObjectSourceConfig,
+	SourceConfig,
 	SourceController,
 	SourceResult,
 	SearchConfig,
@@ -32,17 +32,49 @@ import type {
 	GlobalPagination,
 	MergedResultItem,
 } from "../types";
-import { ALL_SCOPE } from "../types";
+import { ALL_SCOPE, parseScope } from "../types";
+import type { SourceRequest } from "../adapters/types";
+import { MIN_QUERY_LENGTH } from "../constants";
+// `getUIBundleId` supplies the search-query UIBundle id (the isolated swap
+// point) and is resolved by this caller BEFORE the sync query builder runs;
+// `resolveChannelId` derives the discovery channel id from a CMS result;
+// `useSearchableContentTypes` is the session-cached discovery hook;
+// `isValidCmsFqn` validates a selected FQN before it enters state or a query.
+import { getUIBundleId, isConfiguredUIBundleId } from "../adapters/cms/searchChannel";
+import { getOrgSupportsCmsSearch } from "../adapters/cms/api/orgApiVersionService";
+import { resolveChannelId } from "../adapters/cms/channelResolver";
+import { useSearchableContentTypes } from "../adapters/cms/hooks/useSearchableContentTypes";
+import { isValidCmsFqn } from "../adapters/cms/contentTypeUtils";
+import { readLastChannelId, writeLastChannelId } from "../adapters/cms/contentTypeSessionCache";
 
 const URL_SYNC_DEBOUNCE_MS = 300;
-const SCOPE_KEY = "scope";
 
 /**
- * Returns true when `source` should participate in the current scope —
- * either the scope is "all" or the scope matches this source's key.
+ * Returns true when `source` should participate in the current scope. Only the
+ * scope's `base` (`"all"` or a source key) decides membership — a
+ * `"<cmsKey>:<fqn>"` scope has `base === <cmsKey>`, so it naturally includes ONLY
+ * that CMS source and drops every SObject source (CMS-only search).
  */
 function isSourceInScope(scope: SearchScope, sourceKey: string): boolean {
-	return scope === ALL_SCOPE || scope === sourceKey;
+	const { base } = parseScope(scope);
+	return base === ALL_SCOPE || base === sourceKey;
+}
+
+/**
+ * Validates a raw scope string against the config. Accepts `"all"`, any source
+ * key, and the `"<cmsKey>:<fqn>"` form (base must be a CMS source and the FQN
+ * must pass `isValidCmsFqn`). Returns a safe scope, falling back to `"all"`.
+ */
+function validateScope(config: SearchConfig, raw: string): SearchScope {
+	if (raw === ALL_SCOPE) return ALL_SCOPE;
+	const { base, cmsFqn } = parseScope(raw);
+	const source = config.sources.find((s) => s.key === base);
+	if (!source) return ALL_SCOPE;
+	if (cmsFqn !== undefined) {
+		// A content-type scope is only valid on a CMS source with a well-formed FQN.
+		return source.kind === "cms" && isValidCmsFqn(cmsFqn) ? raw : ALL_SCOPE;
+	}
+	return raw;
 }
 
 interface SourceLocalState {
@@ -88,12 +120,16 @@ function validatePageSize(pagination: ResolvedPagination, size: number): number
 }
 
 function initSourceState(
-	source: SObjectSourceConfig,
+	source: SourceConfig,
 	params: URLSearchParams,
 	pagination: ResolvedPagination,
 ): SourceLocalState {
-	const read = readSourceParams(params, source.key, source.filterBy ?? []);
-	const sort = read.sort ?? source.defaultSort ?? null;
+	// `filterBy` / `defaultSort` are SObject-only — a CMS source has neither, so
+	// it seeds with no filters and no default sort.
+	const filterBy = source.kind === "sobject" ? (source.filterBy ?? []) : [];
+	const defaultSort = source.kind === "sobject" ? (source.defaultSort ?? null) : null;
+	const read = readSourceParams(params, source.key, filterBy);
+	const sort = read.sort ?? defaultSort;
 	const pageSize = validatePageSize(pagination, read.pageSize ?? pagination.pageSize);
 	return {
 		filters: read.filters,
@@ -143,16 +179,19 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 	}, []);
 	const initialQ = useMemo(() => searchParams.get(GLOBAL_QUERY_KEY) ?? "", []);
 	const initialScope = useMemo<SearchScope>(() => {
-		// When the caller locks the scope, that always wins over the URL.
+		// When the caller locks the scope, that always wins. A locked scope is
+		// always a plain source key (or "all") — never a content-type form.
 		if (lockedScope !== undefined) {
 			if (lockedScope === ALL_SCOPE) return ALL_SCOPE;
 			return config.sources.some((s) => s.key === lockedScope) ? lockedScope : ALL_SCOPE;
 		}
-		const raw = searchParams.get(SCOPE_KEY);
-		if (!raw || raw === ALL_SCOPE) return ALL_SCOPE;
-		return config.sources.some((s) => s.key === raw) ? raw : ALL_SCOPE;
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, []);
+		// A fresh load always starts in "All" scope. We deliberately do NOT restore
+		// a persisted `?scope=` — a narrowed scope (especially a CMS content-type
+		// scope) depends on runtime-discovered content types that aren't known yet
+		// on first paint, so restoring it would show a blank/orphaned selection.
+		// Starting at "All" re-runs the full search, which re-drives discovery.
+		return ALL_SCOPE;
+	}, [lockedScope, config.sources]);
 
 	const [q, setQState] = useState(initialQ);
 	const [scope, setScopeState] = useState<SearchScope>(initialScope);
@@ -182,11 +221,11 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 		(nextQ: string, nextScope: SearchScope, nextStates: Record<string, SourceLocalState>) => {
 			const params = new URLSearchParams();
 			if (nextQ) params.set(GLOBAL_QUERY_KEY, nextQ);
-			// Skip writing ?scope when caller has locked the scope — it's
-			// already implicit in the page route.
-			if (lockedScope === undefined && nextScope !== ALL_SCOPE) {
-				params.set(SCOPE_KEY, nextScope);
-			}
+			// Intentionally NOT persisting `?scope=`: a fresh load always starts in
+			// "All" (see `initialScope`), so writing the scope would leave a stale
+			// param the next load ignores. `nextScope` is kept in the signature for
+			// call-site compatibility.
+			void nextScope;
 			for (const source of config.sources) {
 				const state = nextStates[source.key];
 				if (!state) continue;
@@ -199,8 +238,12 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 					state.pageIndex,
 					// Omit sort / page size from the URL when they equal the
 					// defaults, so a reset (or untouched source) leaves a clean
-					// query string instead of echoing the defaults.
-					{ sort: source.defaultSort ?? null, pageSize: pagination.pageSize },
+					// query string instead of echoing the defaults. `defaultSort` is
+					// SObject-only (CMS has none).
+					{
+						sort: source.kind === "sobject" ? (source.defaultSort ?? null) : null,
+						pageSize: pagination.pageSize,
+					},
 				);
 			}
 			setSearchParams(params, { replace: true });
@@ -261,11 +304,9 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 		(nextScope: SearchScope) => {
 			// Locked scope wins over user input — silently no-op.
 			if (lockedScope !== undefined) return;
-			// Reject unknown scope values; fall back to "all".
-			const validated: SearchScope =
-				nextScope === ALL_SCOPE || config.sources.some((s) => s.key === nextScope)
-					? nextScope
-					: ALL_SCOPE;
+			// Reject unknown scope values; fall back to "all". Accepts a plain
+			// source key, "all", or the CMS-only "<cmsKey>:<fqn>" form.
+			const validated: SearchScope = validateScope(config, nextScope);
 			setScopeState(validated);
 			// The visible set changes — reset the global page too.
 			setGlobalPageIndex(0);
@@ -280,7 +321,7 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 				return next;
 			});
 		},
-		[config.sources, lockedScope],
+		[config, lockedScope],
 	);
 
 	// -- Reset all -------------------------------------------------------------
@@ -295,7 +336,8 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 		for (const source of config.sources) {
 			empty[source.key] = {
 				filters: [],
-				sort: source.defaultSort ?? null,
+				// `defaultSort` is SObject-only; CMS resets to no sort.
+				sort: source.kind === "sobject" ? (source.defaultSort ?? null) : null,
 				pageSize: pagination.pageSize,
 				pageIndex: 0,
 				afterCursor: undefined,
@@ -309,6 +351,48 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 
 	// -- Fetch -----------------------------------------------------------------
 
+	// -- CMS content-type discovery --------------------------------------------
+	//
+	// The channel id used to DISCOVER content types is derived FROM a CMS search
+	// result (the permanent path — distinct from the temporary `getUIBundleId()`
+	// fed INTO the query). After a CMS result arrives, the fetch effect resolves
+	// it via `resolveChannelId` and stores it here; the session-cached hook then
+	// fetches the searchable content types ONCE per channel. The discovered FQNs
+	// (a) refine every subsequent all/cms-scope request to `contentTypes` and
+	// (b) are exposed for the scope dropdown to append per-type entries.
+	// Seed from the last discovered channel persisted in sessionStorage so a hard
+	// reload rehydrates the content-type scope entries immediately — even when
+	// the current scope is a non-CMS source (which would never re-query CMS and
+	// thus never re-derive the channel id on its own). The persisted pointer is
+	// keyed by UIBundle id, so this seed waits for `getUIBundleId()` (below) —
+	// starting null avoids seeding a DIFFERENT bundle's channel/content types.
+	const [discoveryChannelId, setDiscoveryChannelId] = useState<string | null>(null);
+	// Resolve the current UIBundle id once and seed the discovery channel from
+	// THIS bundle's persisted pointer. Keyed lookup prevents a second bundle
+	// opened in the same session from inheriting the first bundle's channel.
+	useEffect(() => {
+		let cancelled = false;
+		getUIBundleId()
+			.then((uiBundleId) => {
+				if (cancelled || !isConfiguredUIBundleId(uiBundleId)) return;
+				const seeded = readLastChannelId(uiBundleId);
+				if (seeded) setDiscoveryChannelId((prev) => prev ?? seeded);
+			})
+			.catch(() => {
+				// Seeding is best-effort; a CMS result will still drive discovery.
+			});
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+	const { contentTypes: discoveredContentTypes } = useSearchableContentTypes(discoveryChannelId);
+	// The query filter and request key work in FQNs only; the `{ fqn, label }`
+	// objects are threaded to the handle for the scope dropdown's display labels.
+	const discoveredContentTypeFqns = useMemo(
+		() => discoveredContentTypes.map((ct) => ct.fqn),
+		[discoveredContentTypes],
+	);
+
 	const requestKey = useMemo(() => {
 		// Stable string key that changes only when something fetch-relevant changes.
 		// Sources outside the current scope are listed (with `skip: true`) so
@@ -316,7 +400,14 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 		// per-source state to the diff.
 		return JSON.stringify({
 			q,
+			// `scope` already carries the selected CMS content-type fqn (the
+			// "<cmsKey>:<fqn>" form), so a content-type selection re-fires the fetch
+			// with no imperative refetch.
 			scope,
+			// Discovered content types are part of the key so that once discovery
+			// completes, the effect re-fires and every in-scope CMS request switches
+			// from the bootstrap call (no `contentTypes`) to the discovered set.
+			ct: discoveredContentTypeFqns,
 			// Merged mode paginates globally: every in-scope source fetches the
 			// same front-anchored window, so the global page/size drive the fetch
 			// rather than per-source cursors.
@@ -336,10 +427,24 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 				};
 			}),
 		});
-	}, [q, scope, sourceStates, config.sources, mergedMode, globalPageIndex, globalPageSize]);
+	}, [
+		q,
+		scope,
+		discoveredContentTypes,
+		sourceStates,
+		config.sources,
+		mergedMode,
+		globalPageIndex,
+		globalPageSize,
+	]);
 
 	const [results, setResults] = useState<Record<string, SourceResult>>({});
+	// Per-source errors, keyed by `source.key`. A source that failed while a
+	// sibling succeeded surfaces its own message here without blanking others.
+	const [sourceErrors, setSourceErrors] = useState<Record<string, string>>({});
 	const [loading, setLoading] = useState(true);
+	// Page-level error — set ONLY when EVERY in-scope source failed, or on a
+	// whole-request / network failure (`runSearch` throwing).
 	const [error, setError] = useState<string | null>(null);
 	const fetchGenRef = useRef(0);
 
@@ -347,6 +452,7 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 		const generation = ++fetchGenRef.current;
 		setLoading(true);
 		setError(null);
+		setSourceErrors({});
 
 		const activeSources = config.sources.filter((source) => isSourceInScope(scope, source.key));
 
@@ -357,6 +463,25 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 			return;
 		}
 
+		// Keyword gate: only fire a search once the user has typed at least
+		// MIN_QUERY_LENGTH characters. On landing (or after clearing the box) `q`
+		// is empty, so we clear results and exit WITHOUT firing a request — no
+		// unfiltered "browse the first page" query, and no CMS bootstrap call
+		// until there's a keyword. The minimum matters beyond UX: the SObject and
+		// CMS search backends reject terms shorter than MIN_QUERY_LENGTH, which
+		// otherwise surfaces as "Search failed for this source." across every
+		// source. Gating here keeps the too-short case client-side.
+		if (q.trim().length < MIN_QUERY_LENGTH) {
+			setResults({});
+			setLoading(false);
+			return;
+		}
+
+		// A "<cmsKey>:<fqn>" scope narrows to one content type. Because its `base`
+		// is the CMS source key, `activeSources` already excludes every SObject
+		// source (CMS-only search); the fqn flows through as `contentTypes = [fqn]`.
+		const { cmsFqn } = parseScope(scope);
+
 		// Merged mode: fetch the whole front-anchored window — (page + 1) * size
 		// rows — from every in-scope source, with no cursor. Concatenating these
 		// and slicing [page*size, (page+1)*size) yields the exact global page,
@@ -364,32 +489,164 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 		// the true merged prefix regardless of how rows interleave.
 		const mergedFetchSize = (globalPageIndex + 1) * globalPageSize;
 
-		const requests = activeSources.map((source) => {
-			const st = sourceStates[source.key]!;
-			return {
-				source,
-				q,
-				filters: st.filters,
-				sort: st.sort,
-				pageSize: mergedMode ? mergedFetchSize : st.pageSize,
-				afterCursor: mergedMode ? undefined : st.afterCursor,
-			};
-		});
+		// Resolve the async CMS preconditions ONCE, up front, then thread them into
+		// each CMS request so the synchronous query builder never resolves a promise:
+		//  - the UIBundle id (`getUIBundleId`), and
+		//  - whether the build-time API version carries the CMS search backend
+		//    (`getOrgSupportsCmsSearch`).
+		let cancelled = false;
+		// True once this run's request set is a DISCOVERY-driven refetch: an
+		// all/cms-scope search that auto-applies the content-type FQNs discovered
+		// from a prior successful CMS result (as opposed to a user-selected fqn).
+		// Such a refetch only NARROWS an already-successful bootstrap, so if it
+		// fails it must not destroy the good bootstrap results or raise a
+		// page-level error — content-type narrowing is an enhancement, not a
+		// hard requirement. Read in `.catch` below.
+		let isDiscoveryRefetch = false;
+		Promise.all([getUIBundleId(), getOrgSupportsCmsSearch()])
+			.then(([uiBundleId, orgSupportsCmsSearch]) => {
+				if (cancelled || generation !== fetchGenRef.current) return;
+
+				const requests: SourceRequest[] = activeSources.flatMap((source) => {
+					const st = sourceStates[source.key]!;
+					const base: SourceRequest = {
+						source,
+						q,
+						filters: st.filters,
+						sort: st.sort,
+						pageSize: mergedMode ? mergedFetchSize : st.pageSize,
+						afterCursor: mergedMode ? undefined : st.afterCursor,
+					};
+					if (source.kind !== "cms") return [base];
+					// CMS is gated on (a) a CONFIGURED (9YE-shaped) UIBundle id and
+					// (b) a build-time API version with the CMS search backend (v68+,
+					// core 264+). Skip silently when either is absent.
+					if (!isConfiguredUIBundleId(uiBundleId) || !orgSupportsCmsSearch) {
+						return [];
+					}
+					// CMS request: attach the resolved channel id and content types.
+					//   - specific fqn selected → exactly that type.
+					//   - all / cms-key scope → the discovered set if known, else
+					//     omit `contentTypes` entirely (the bootstrap call).
+					const contentTypes = cmsFqn
+						? [cmsFqn]
+						: discoveredContentTypeFqns.length > 0
+							? discoveredContentTypeFqns
+							: undefined;
+					// A non-fqn scope that carries auto-discovered content types is a
+					// discovery-driven refetch — the bootstrap CMS call already
+					// succeeded (that's how the FQNs were discovered). Flag it so a
+					// failure here degrades to the bootstrap results instead of
+					// blanking them (see `.catch`).
+					if (!cmsFqn && discoveredContentTypeFqns.length > 0) {
+						isDiscoveryRefetch = true;
+					}
+					return [{ ...base, uiBundleId, contentTypes }];
+				});
+
+				// Every in-scope source was gated out (e.g. a CMS-only scope while CMS
+				// is not yet configured): nothing to fetch. Clear results and stop,
+				// mirroring the "all sources gated out" branch above.
+				if (requests.length === 0) {
+					setResults({});
+					setLoading(false);
+					return;
+				}
 
-		runSearch(requests)
-			.then((resp) => {
-				if (generation !== fetchGenRef.current) return;
-				setResults(resp);
+				// The sources actually queried (CMS may have been skipped above). Used
+				// for the all-failed check so a skipped/not-configured CMS source is
+				// never counted as a failure.
+				const requestedSources = requests.map((r) => r.source);
+
+				return runSearch(requests).then((outcome) => {
+					if (cancelled || generation !== fetchGenRef.current) return;
+					const { results: nextResults, errors: nextErrors } = outcome;
+
+					// Discovery-driven refetch that came back with a failed source:
+					// the narrowing query erred, but the bootstrap results are still
+					// valid and on screen. Keep them — fall back to the prior result
+					// for any source this refetch failed to produce, and drop the
+					// spurious error rather than blanking the grid / raising a
+					// page-level error below. (Sources that DID return data still
+					// update to the narrowed set.)
+					if (isDiscoveryRefetch && requestedSources.some((s) => nextErrors[s.key] != null)) {
+						setResults((prev) => {
+							const merged = { ...prev };
+							for (const source of requestedSources) {
+								if (nextResults[source.key] != null) merged[source.key] = nextResults[source.key];
+								// else: refetch produced nothing for this source — retain prev.
+							}
+							return merged;
+						});
+						// Discovery is already complete for this channel, so there is no
+						// further channel id to resolve; just stop here without touching
+						// sourceErrors / the page-level error.
+						return;
+					}
+
+					setResults(nextResults);
+					setSourceErrors(nextErrors);
+
+					// Page-level error only when EVERY queried source failed; a mix of
+					// success + failure surfaces per-source (below) with the grid intact.
+					const allFailed =
+						requestedSources.length > 0 &&
+						requestedSources.every((source) => nextErrors[source.key] != null);
+					if (allFailed) {
+						// De-duplicate identical messages: when every source fails with the
+						// same backend error (e.g. "Search isn't enabled on this channel"),
+						// show it once rather than repeating it per source in the banner.
+						const combined = [
+							...new Set(
+								requestedSources
+									.map((source) => nextErrors[source.key])
+									.filter((m): m is string => !!m),
+							),
+						].join("; ");
+						setError(combined || "Unified search failed");
+					}
+
+					// Content-type discovery: once a CMS source returns data, derive the
+					// discovery channel id from it and hand it to the session-cached hook.
+					for (const source of requestedSources) {
+						if (source.kind !== "cms") continue;
+						const channelId = resolveChannelId(nextResults[source.key]);
+						if (channelId) {
+							setDiscoveryChannelId((prev) => (prev === channelId ? prev : channelId));
+							// Persist the pointer keyed by THIS UIBundle so a reload seeds
+							// only this bundle's channel — never a different bundle's.
+							writeLastChannelId(uiBundleId, channelId);
+							break;
+						}
+					}
+				});
 			})
 			.catch((err: unknown) => {
-				if (generation !== fetchGenRef.current) return;
+				if (cancelled || generation !== fetchGenRef.current) return;
 				console.error(err);
+				// A discovery-driven refetch (content-type narrowing over an
+				// already-successful bootstrap) that fails must NOT surface as a
+				// page-level error or blank the good bootstrap results — the user
+				// still has valid, un-narrowed results on screen. Degrade silently
+				// and keep them; `finally` resets loading below.
+				if (isDiscoveryRefetch) return;
+				// A whole-request / network failure (or a failure to resolve the
+				// channel id) is page-level, preserving the original behaviour.
 				setError(err instanceof Error ? err.message : "Unified search failed");
+				// Clear stale rows so a prior page's results don't linger under the
+				// error banner (the per-source layout would otherwise keep rendering
+				// them). `finally` resets loading below.
+				setResults({});
+				setSourceErrors({});
 			})
 			.finally(() => {
-				if (generation !== fetchGenRef.current) return;
+				if (cancelled || generation !== fetchGenRef.current) return;
 				setLoading(false);
 			});
+
+		return () => {
+			cancelled = true;
+		};
 		// requestKey is the dependency-of-record; sourceStates and q are
 		// captured via the ref-like closure above each render.
 		// eslint-disable-next-line react-hooks/exhaustive-deps
@@ -469,7 +726,9 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 				config: source,
 				result,
 				loading,
-				error,
+				// Per-source error (set only when THIS source failed) — not the
+				// page-level `error` (which is set only when every source failed).
+				error: sourceErrors[source.key] ?? null,
 				filters: {
 					active: state?.filters ?? [],
 					set: setFilter,
@@ -492,7 +751,7 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 			};
 		}
 		return out;
-	}, [config.sources, sourceStates, results, loading, error, updateSource, pagination]);
+	}, [config.sources, sourceStates, results, loading, sourceErrors, updateSource, pagination]);
 
 	const scopeLocked = lockedScope !== undefined;
 
@@ -588,8 +847,10 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 			goToNextPage: () => setGlobalPageIndex((p) => p + 1),
 			goToPreviousPage: () => setGlobalPageIndex((p) => Math.max(0, p - 1)),
 			goToPage: (next: number) => setGlobalPageIndex(Math.max(0, Math.floor(next))),
+			// Validate the requested size against the configured options before it
+			// becomes `$cmsLimit` / `first`, matching the per-source setter.
 			setPageSize: (size: number) => {
-				setGlobalPageSize(size);
+				setGlobalPageSize(validatePageSize(pagination, size));
 				setGlobalPageIndex(0);
 			},
 		};
@@ -683,6 +944,7 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 			globalPagination,
 			loading,
 			error,
+			discoveredContentTypes,
 			resetAll,
 		}),
 		[
@@ -697,6 +959,7 @@ export function useSearch(config: SearchConfig, options?: UseSearchOptions): Sea
 			globalPagination,
 			loading,
 			error,
+			discoveredContentTypes,
 			resetAll,
 		],
 	);

package/dist/force-app/main/default/uiBundles/reactinternalapp/src/features/search/index.ts

@@ -31,6 +31,11 @@ export { PaginationControls } from "./components/controls/PaginationControls";
 export { ScopeSelector } from "./components/controls/ScopeSelector";
 export { ActiveFilters } from "./components/filters/ActiveFilters";
 export { DefaultResultRow } from "./components/results/DefaultResultRow";
+export { GlobalSearchBox } from "./components/GlobalSearchBox";
+export type { GlobalSearchBoxProps } from "./components/GlobalSearchBox";
+export { CmsResultRow } from "./components/results/CmsResultRow";
+export { resolveResultRenderer } from "./components/results/resolveResultRenderer";
+export type { ResultRenderer } from "./components/results/resolveResultRenderer";
 export { DefaultFilterPanel } from "./components/filters/DefaultFilterPanel";
 export {
 	FilterProvider,
@@ -72,11 +77,30 @@ export { fetchDistinctValues } from "./api/distinctValuesService";
 export type { PicklistOption } from "./api/distinctValuesService";
 
 export { config } from "./loadConfig";
+export { MIN_QUERY_LENGTH } from "./constants";
 
-export { ALL_SCOPE } from "./types";
+// CMS adapter surface — the registered adapter, its config type, and the
+// runtime content-type discovery hook. Apps adding a CMS source import
+// `CmsSourceConfig` for typing; advanced integrations can reuse the adapter
+// contracts and the discovery hook directly.
+export { cmsAdapter } from "./adapters/cms";
+export { useSearchableContentTypes } from "./adapters/cms/hooks/useSearchableContentTypes";
+export type { UseSearchableContentTypesResult } from "./adapters/cms/hooks/useSearchableContentTypes";
+export { formatContentTypeLabel, isValidCmsFqn } from "./adapters/cms/contentTypeUtils";
+export type {
+	SourceAdapter,
+	SourceRequest as AdapterSourceRequest,
+	QueryFragmentContribution,
+} from "./adapters/types";
+export type { CmsSourceConfig, CmsSearchItem, CmsSearchResponse } from "./adapters/cms/types";
+export { getAdapter } from "./adapters/registry";
+export type { RunSearchOutcome } from "./api/searchService";
+
+export { ALL_SCOPE, CMS_SCOPE_SEPARATOR, parseScope } from "./types";
 export type {
 	DisplayField,
 	SObjectSourceConfig,
+	SourceConfig,
 	SearchConfig,
 	SearchPaginationConfig,
 	SourceController,
@@ -84,6 +108,7 @@ export type {
 	SourcePageInfo,
 	SearchHandle,
 	SearchScope,
+	ParsedScope,
 	RenderResultFn,
 	GlobalPagination,
 	MergedResultItem,