@hashicorp/design-system-mcp 0.1.0

package/dist/stores/components/index.js

@@ -0,0 +1,114 @@
+/**
+ * Copyright IBM Corp. 2021, 2026
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { normalizeLookupValue } from "../../catalog/normalize.js";
+import { DEFAULT_CATALOG_SOURCE, createCatalogLoader, } from "../../catalog/loader.js";
+import { getComponentLookupKeys, normalizeComponentName, toComponentRecord, toComponentSummary, } from "./lookup.js";
+import { componentCatalogSchema } from "./schema.js";
+import { searchRanked, getCommonPrefixLength } from "../rank.js";
+const toSearchBlob = (component) => {
+    return [
+        component.name,
+        component.name.replaceAll("::", ""),
+        component.modulePath,
+        component.modulePath.replaceAll(/[/-]/gu, " "),
+        component.docsPath ?? "",
+    ]
+        .join(" ")
+        .toLowerCase();
+};
+// the four ways a caller writes a component: template invocation, bare name, imported class
+// and module path
+const toRankable = (component) => {
+    return {
+        identities: [
+            normalizeLookupValue(component.name),
+            normalizeComponentName(component.name),
+            normalizeLookupValue(component.name.replaceAll("::", "")),
+            normalizeLookupValue(component.modulePath),
+        ],
+        blob: toSearchBlob(component),
+    };
+};
+export const parseComponentCatalog = (value) => {
+    return componentCatalogSchema.parse(value);
+};
+export const createComponentCatalogStore = (catalog, source = DEFAULT_CATALOG_SOURCE) => {
+    const componentRecords = catalog.components.map((entry) => toComponentRecord(entry, catalog.valueSets ?? {}));
+    const componentLookup = new Map();
+    for (const [index, entry] of catalog.components.entries()) {
+        const component = componentRecords[index];
+        if (component === undefined) {
+            continue;
+        }
+        else {
+            for (const key of getComponentLookupKeys(entry)) {
+                if (!componentLookup.has(key)) {
+                    componentLookup.set(key, component);
+                }
+            }
+        }
+    }
+    const searchComponents = ({ query, limit }) => {
+        if (normalizeLookupValue(query).length === 0) {
+            return { totalMatches: 0, hits: [] };
+        }
+        const { totalMatches, hits } = searchRanked({
+            records: componentRecords,
+            query,
+            limit,
+            toRankable,
+        });
+        return {
+            totalMatches,
+            hits: hits.map((component) => toComponentSummary(component)),
+        };
+    };
+    /**
+     * A name that resolves to nothing is usually a typo or a half-remembered nesting, not a
+     * different concept, so the ranked search comes first and prefix overlap is the fallback
+     * that survives a wrong tail: `Hds::Buton` still reaches `Hds::Button`.
+     */
+    const suggestComponentNames = (componentName, limit) => {
+        const { hits } = searchComponents({ query: componentName, limit });
+        if (hits.length > 0) {
+            return hits.map((hit) => hit.name);
+        }
+        const requested = normalizeComponentName(componentName);
+        return componentRecords
+            .map((component) => ({
+            name: component.name,
+            overlap: getCommonPrefixLength(normalizeComponentName(component.name), requested),
+        }))
+            .filter((candidate) => candidate.overlap > 0)
+            .sort((left, right) => right.overlap === left.overlap
+            ? left.name.localeCompare(right.name)
+            : right.overlap - left.overlap)
+            .slice(0, limit)
+            .map((candidate) => candidate.name);
+    };
+    return {
+        getMeta: () => ({
+            totalComponentCount: componentRecords.length,
+            source,
+        }),
+        listComponents: () => componentRecords.map((component) => toComponentSummary(component)),
+        getComponentByName: (componentName) => {
+            return componentLookup.get(normalizeLookupValue(componentName)) ?? null;
+        },
+        searchComponents,
+        suggestComponentNames,
+    };
+};
+const componentCatalogLoader = createCatalogLoader({
+    specifier: "@hashicorp/design-system-components/component-catalog.json",
+    anchors: ["project-root", "default"],
+    create: (value, source) => createComponentCatalogStore(parseComponentCatalog(value), source),
+});
+export const loadComponentCatalog = () => {
+    return componentCatalogLoader.load();
+};
+export const getOrLoadComponentStore = () => {
+    return componentCatalogLoader.getOrLoad();
+};

package/dist/stores/components/lookup.js

@@ -0,0 +1,55 @@
+/**
+ * Copyright IBM Corp. 2021, 2026
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { normalizeLookupValue } from "../../catalog/normalize.js";
+const HDS_NAMESPACE_PREFIX = "hds::";
+export const normalizeComponentName = (value) => {
+    const normalized = normalizeLookupValue(value);
+    return normalized.startsWith(HDS_NAMESPACE_PREFIX)
+        ? normalized.slice(HDS_NAMESPACE_PREFIX.length)
+        : normalized;
+};
+export const getComponentLookupKeys = (entry) => {
+    const invocation = normalizeLookupValue(entry.name);
+    const withoutNamespace = normalizeComponentName(entry.name);
+    return [
+        invocation,
+        withoutNamespace,
+        invocation.replaceAll("::", ""),
+        withoutNamespace.replaceAll("::", ""),
+        // the specifier an import uses, which is the one form a caller can copy out of a
+        // stack trace or an Embroider error rather than retype
+        normalizeLookupValue(entry.modulePath),
+    ];
+};
+const resolveArgValues = (arg, valueSets) => {
+    if (arg.valuesRef === undefined) {
+        return arg;
+    }
+    else {
+        const values = valueSets[arg.valuesRef];
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { valuesRef: _valuesRef, ...rest } = arg;
+        return values === undefined ? rest : { ...rest, values };
+    }
+};
+export const toComponentRecord = (entry, valueSets = {}) => {
+    return {
+        name: entry.name,
+        modulePath: entry.modulePath,
+        ...(entry.docsPath === undefined ? {} : { docsPath: entry.docsPath }),
+        ...(entry.element === undefined ? {} : { element: entry.element }),
+        args: entry.args.map((arg) => resolveArgValues(arg, valueSets)),
+        blocks: entry.blocks,
+    };
+};
+export const toComponentSummary = (component) => {
+    return {
+        name: component.name,
+        modulePath: component.modulePath,
+        ...(component.docsPath === undefined
+            ? {}
+            : { docsPath: component.docsPath }),
+    };
+};

package/dist/stores/components/schema.js

@@ -0,0 +1,37 @@
+/**
+ * Copyright IBM Corp. 2021, 2026
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { z } from "zod";
+const componentArgSchema = z.object({
+    name: z.string().min(1),
+    type: z.string().min(1),
+    required: z.boolean(),
+    values: z.array(z.string()).optional(),
+    valuesRef: z.string().min(1).optional(),
+    inheritedFrom: z.string().min(1).optional(),
+});
+const componentBlockYieldSchema = z.object({
+    name: z.string().min(1),
+    type: z.string().min(1),
+});
+const componentBlockSchema = z.object({
+    name: z.string().min(1),
+    yields: z.array(componentBlockYieldSchema),
+});
+export const componentCatalogEntrySchema = z
+    .object({
+    name: z.string().min(1),
+    modulePath: z.string().min(1),
+    docsPath: z.string().min(1).optional(),
+    element: z.string().min(1).optional(),
+    args: z.array(componentArgSchema),
+    blocks: z.array(componentBlockSchema),
+})
+    .catchall(z.any());
+export const componentCatalogSchema = z
+    .object({
+    valueSets: z.record(z.string(), z.array(z.string())).optional(),
+    components: z.array(componentCatalogEntrySchema),
+})
+    .catchall(z.any());

package/dist/stores/docs/constants.js

@@ -0,0 +1,163 @@
+/**
+ * Copyright IBM Corp. 2021, 2026
+ * SPDX-License-Identifier: MPL-2.0
+ */
+export const SITE_BASE_URL = "https://helios.hashicorp.design/";
+export const DOCS_CATALOG_FILE_NAME = "docs-catalog.json";
+export const NOT_FOUND_SUGGESTION_LIMIT = 5;
+export const SNIPPET_MAX_LENGTH = 300;
+// BM25 ranking tunables
+// https://lucene.apache.org/core/9_12_3/core/org/apache/lucene/search/similarities/BM25Similarity.html
+export const BM25_K1 = 1.6;
+export const BM25_B = 0.6;
+// a page match says "this page is about your query", a chunk match says "this passage is"
+export const PAGE_SCORE_WEIGHT = 1.5;
+export const CHUNK_SCORE_WEIGHT = 1;
+export const PAGE_NAME_MATCH_WEIGHT = 1;
+// how many passages any one page may contribute to a result window
+export const MAX_HITS_PER_ROUTE = 3;
+export const PAGE_FIELD_WEIGHTS = {
+    name: 3,
+    title: 3,
+    keywords: 5,
+    description: 1,
+};
+export const CHUNK_FIELD_WEIGHTS = {
+    heading: 6,
+    ancestorHeadings: 2,
+    tab: 1,
+    body: 1,
+};
+export const VERSION_HISTORY_TAB = "Version history";
+export const VERSION_HISTORY_SCORE_MULTIPLIER = 0.6;
+// reduce results for partial matches
+export const PAGE_ONLY_CHUNK_LIMIT = 3;
+export const STOPWORDS = new Set([
+    "about",
+    "above",
+    "after",
+    "again",
+    "against",
+    "all",
+    "also",
+    "am",
+    "an",
+    "and",
+    "any",
+    "are",
+    "as",
+    "at",
+    "be",
+    "because",
+    "been",
+    "before",
+    "being",
+    "below",
+    "between",
+    "both",
+    "but",
+    "by",
+    "can",
+    "cannot",
+    "could",
+    "did",
+    "do",
+    "does",
+    "doing",
+    "down",
+    "during",
+    "each",
+    "few",
+    "for",
+    "from",
+    "further",
+    "had",
+    "has",
+    "have",
+    "having",
+    "he",
+    "her",
+    "here",
+    "hers",
+    "herself",
+    "him",
+    "himself",
+    "his",
+    "how",
+    "if",
+    "in",
+    "into",
+    "is",
+    "it",
+    "its",
+    "itself",
+    "just",
+    "me",
+    "more",
+    "most",
+    "my",
+    "myself",
+    "no",
+    "nor",
+    "not",
+    "now",
+    "of",
+    "off",
+    "on",
+    "once",
+    "only",
+    "or",
+    "other",
+    "ought",
+    "our",
+    "ours",
+    "ourselves",
+    "out",
+    "over",
+    "own",
+    "same",
+    "she",
+    "should",
+    "so",
+    "some",
+    "such",
+    "than",
+    "that",
+    "the",
+    "their",
+    "theirs",
+    "them",
+    "themselves",
+    "then",
+    "there",
+    "these",
+    "they",
+    "this",
+    "those",
+    "through",
+    "to",
+    "too",
+    "under",
+    "until",
+    "up",
+    "very",
+    "was",
+    "we",
+    "were",
+    "what",
+    "when",
+    "where",
+    "which",
+    "while",
+    "who",
+    "whom",
+    "why",
+    "will",
+    "with",
+    "would",
+    "you",
+    "your",
+    "yours",
+    "yourself",
+    "yourselves",
+]);

package/dist/stores/docs/index.js

@@ -0,0 +1,322 @@
+/**
+ * Copyright IBM Corp. 2021, 2026
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { memoizeCatalogLoader } from "../../catalog/loader.js";
+import { getMcpPackageDirectory } from "../../catalog/project-root.js";
+import { normalizeLookupValue } from "../../catalog/normalize.js";
+import { CHUNK_FIELD_WEIGHTS, CHUNK_SCORE_WEIGHT, DOCS_CATALOG_FILE_NAME, NOT_FOUND_SUGGESTION_LIMIT, MAX_HITS_PER_ROUTE, PAGE_FIELD_WEIGHTS, PAGE_NAME_MATCH_WEIGHT, PAGE_ONLY_CHUNK_LIMIT, PAGE_SCORE_WEIGHT, VERSION_HISTORY_SCORE_MULTIPLIER, VERSION_HISTORY_TAB, } from "./constants.js";
+import { buildSnippet, getAncestorHeadings, getChunkHeading, getPageNameTerms, matchesDocsPath, matchesFilters, normalizeRoute, toChunkRecord, toPageRecord, } from "./lookup.js";
+import { docsCatalogSchema } from "./schema.js";
+import { buildBm25Index, getNameMatchRatio, hasTerm, scoreBm25, } from "./search-index.js";
+import { tokenize, tokenizeQuery } from "./tokenize.js";
+import { getCommonPrefixLength } from "../rank.js";
+// splits the raw query into the words a caller would recognize
+const QUERY_WORD_PATTERN = /[A-Za-z0-9][A-Za-z0-9.:@_-]*/g;
+const roundScore = (value) => {
+    return Math.round(value * 10_000) / 10_000;
+};
+export const parseDocsCatalog = (value) => {
+    return docsCatalogSchema.parse(value);
+};
+// trims the result window so no single page can hold all of it, in score order
+const diversifyByPage = (candidates, limit) => {
+    const kept = [];
+    const overflow = [];
+    const countsByPage = new Map();
+    for (const candidate of candidates) {
+        if (kept.length >= limit) {
+            break;
+        }
+        const seen = countsByPage.get(candidate.pageIndex) ?? 0;
+        if (seen >= MAX_HITS_PER_ROUTE) {
+            overflow.push(candidate);
+            continue;
+        }
+        countsByPage.set(candidate.pageIndex, seen + 1);
+        kept.push(candidate);
+    }
+    return kept.length >= limit
+        ? kept
+        : [...kept, ...overflow.slice(0, limit - kept.length)];
+};
+export const createDocsCatalogStore = (catalog) => {
+    const pages = [];
+    const pageNameTerms = [];
+    const chunks = [];
+    const chunkPageIndexes = [];
+    const pageIndexByRoute = new Map();
+    const chunkIndexById = new Map();
+    const sections = new Set();
+    const tabs = new Set();
+    for (const page of Object.values(catalog.pages)) {
+        const pageIndex = pages.length;
+        const record = toPageRecord(page);
+        pages.push(record);
+        pageNameTerms.push(getPageNameTerms(record));
+        pageIndexByRoute.set(normalizeRoute(page.route), pageIndex);
+        sections.add(page.section);
+        for (const chunk of page.chunks) {
+            chunkIndexById.set(chunk.id.toLowerCase(), chunks.length);
+            chunkPageIndexes.push(pageIndex);
+            chunks.push(toChunkRecord(chunk, page));
+            if (chunk.tab !== undefined) {
+                tabs.add(chunk.tab);
+            }
+        }
+    }
+    const normalizedSections = new Set([...sections].map((section) => normalizeLookupValue(section)));
+    const normalizedTabs = new Set([...tabs].map((tab) => normalizeLookupValue(tab)));
+    let indexes = null;
+    const getIndexes = () => {
+        if (indexes !== null) {
+            return indexes;
+        }
+        const pageDocuments = pages.map((page) => [
+            { value: page.route, weight: PAGE_FIELD_WEIGHTS.name },
+            { value: page.title, weight: PAGE_FIELD_WEIGHTS.title },
+            { value: page.keywords, weight: PAGE_FIELD_WEIGHTS.keywords },
+            {
+                value: [page.description, page.caption].filter((value) => value !== undefined),
+                weight: PAGE_FIELD_WEIGHTS.description,
+            },
+        ]);
+        const chunkDocuments = chunks.map((chunk) => [
+            { value: getChunkHeading(chunk), weight: CHUNK_FIELD_WEIGHTS.heading },
+            {
+                value: getAncestorHeadings(chunk),
+                weight: CHUNK_FIELD_WEIGHTS.ancestorHeadings,
+            },
+            { value: chunk.tab, weight: CHUNK_FIELD_WEIGHTS.tab },
+            { value: chunk.text, weight: CHUNK_FIELD_WEIGHTS.body },
+            { value: chunk.symbols, weight: CHUNK_FIELD_WEIGHTS.body },
+        ]);
+        indexes = {
+            page: buildBm25Index(pageDocuments),
+            chunk: buildBm25Index(chunkDocuments),
+        };
+        return indexes;
+    };
+    const analyzeQuery = (query, pageIndex, chunkIndex) => {
+        const displayByTerm = new Map();
+        const matchedTerms = [];
+        const unmatchedTerms = [];
+        for (const word of query.match(QUERY_WORD_PATTERN) ?? []) {
+            const wordTerms = tokenize(word);
+            // a word that is entirely stopwords is neither a match nor a miss
+            if (wordTerms.length === 0) {
+                continue;
+            }
+            let isMatched = false;
+            for (const term of wordTerms) {
+                if (!displayByTerm.has(term)) {
+                    displayByTerm.set(term, word);
+                }
+                if (hasTerm(pageIndex, term) || hasTerm(chunkIndex, term)) {
+                    isMatched = true;
+                }
+            }
+            const bucket = isMatched ? matchedTerms : unmatchedTerms;
+            if (!bucket.includes(word)) {
+                bucket.push(word);
+            }
+        }
+        const terms = tokenizeQuery(query);
+        return {
+            terms,
+            termSet: new Set(terms),
+            displayByTerm,
+            matchedTerms,
+            unmatchedTerms,
+        };
+    };
+    const resolveFilters = (query) => {
+        const filters = {};
+        const unknownFilters = [];
+        /**
+         * A value that normalizes to nothing — `"  "`, or a `docsPath` of `"/"` — is reported and
+         * then dropped. Applying it would match no chunk at all, and echoing it back in `filters`
+         * would name an empty string as the filter that did the excluding.
+         */
+        if (query.section !== undefined) {
+            const section = normalizeLookupValue(query.section);
+            if (section.length > 0) {
+                filters.section = section;
+            }
+            if (section.length === 0 || !normalizedSections.has(section)) {
+                unknownFilters.push(`section: ${query.section}`);
+            }
+        }
+        if (query.tab !== undefined) {
+            const tab = normalizeLookupValue(query.tab);
+            if (tab.length > 0) {
+                filters.tab = tab;
+            }
+            if (tab.length === 0 || !normalizedTabs.has(tab)) {
+                unknownFilters.push(`tab: ${query.tab}`);
+            }
+        }
+        if (query.docsPath !== undefined) {
+            const docsPath = normalizeRoute(query.docsPath);
+            if (docsPath.length > 0) {
+                filters.docsPath = docsPath;
+            }
+            const isKnownRoute = docsPath.length > 0 &&
+                [...pageIndexByRoute.keys()].some((route) => matchesDocsPath(route, docsPath));
+            if (!isKnownRoute) {
+                unknownFilters.push(`docsPath: ${query.docsPath}`);
+            }
+        }
+        return { filters, unknownFilters };
+    };
+    const search = (query) => {
+        const { page: pageIndex, chunk: chunkIndex } = getIndexes();
+        const analysis = analyzeQuery(query.query, pageIndex, chunkIndex);
+        const { filters, unknownFilters } = resolveFilters(query);
+        const emptyOutcome = {
+            filters,
+            unknownFilters,
+            matchedTerms: analysis.matchedTerms,
+            unmatchedTerms: analysis.unmatchedTerms,
+            totalMatches: 0,
+            hits: [],
+        };
+        if (analysis.terms.length === 0) {
+            return emptyOutcome;
+        }
+        const pageScores = scoreBm25(pageIndex, analysis.terms);
+        const chunkScores = scoreBm25(chunkIndex, analysis.terms);
+        const nameMatchRatios = pageNameTerms.map((nameTerms) => getNameMatchRatio(analysis.termSet, nameTerms));
+        const isVersionHistoryScoped = filters.tab === normalizeLookupValue(VERSION_HISTORY_TAB);
+        const candidates = [];
+        const pageOnlyCounts = new Map();
+        for (const [index, chunk] of chunks.entries()) {
+            const chunkScore = chunkScores.scores[index];
+            const ownerPageIndex = chunkPageIndexes[index];
+            const pageScore = pageScores.scores[ownerPageIndex];
+            if (chunkScore === 0 && pageScore === 0) {
+                continue;
+            }
+            if (!matchesFilters(chunk, filters)) {
+                continue;
+            }
+            if (chunkScore === 0) {
+                const seen = pageOnlyCounts.get(ownerPageIndex) ?? 0;
+                if (seen >= PAGE_ONLY_CHUNK_LIMIT) {
+                    continue;
+                }
+                pageOnlyCounts.set(ownerPageIndex, seen + 1);
+            }
+            let score = PAGE_SCORE_WEIGHT * pageScore + CHUNK_SCORE_WEIGHT * chunkScore;
+            score *= 1 + PAGE_NAME_MATCH_WEIGHT * nameMatchRatios[ownerPageIndex];
+            if (chunk.tab === VERSION_HISTORY_TAB && !isVersionHistoryScoped) {
+                score *= VERSION_HISTORY_SCORE_MULTIPLIER;
+            }
+            candidates.push({ chunkIndex: index, pageIndex: ownerPageIndex, score });
+        }
+        if (candidates.length === 0) {
+            return emptyOutcome;
+        }
+        candidates.sort((left, right) => right.score === left.score
+            ? left.chunkIndex - right.chunkIndex
+            : right.score - left.score);
+        const topScore = candidates[0].score;
+        const hits = diversifyByPage(candidates, query.limit).map((candidate) => {
+            const chunk = chunks[candidate.chunkIndex];
+            const pageMatched = pageScores.matchedTermsByDocument.get(candidate.pageIndex) ?? new Set();
+            const pageMatchedTerms = [...pageMatched]
+                .map((term) => analysis.displayByTerm.get(term) ?? term)
+                .filter((term, index, all) => all.indexOf(term) === index);
+            return {
+                chunk,
+                page: pages[candidate.pageIndex],
+                score: roundScore(candidate.score),
+                relScore: topScore === 0 ? 0 : roundScore(candidate.score / topScore),
+                pageMatchedTerms,
+                snippet: buildSnippet(chunk.text, analysis.termSet),
+            };
+        });
+        return {
+            filters,
+            unknownFilters,
+            matchedTerms: analysis.matchedTerms,
+            unmatchedTerms: analysis.unmatchedTerms,
+            totalMatches: candidates.length,
+            hits,
+        };
+    };
+    // a chunk id is route-shaped, so it tolerates the same stray casing and slashes a route does
+    const getChunkById = (id) => {
+        const index = chunkIndexById.get(normalizeRoute(id));
+        return index === undefined ? null : chunks[index];
+    };
+    const getChildChunks = (id) => {
+        const parent = getChunkById(id);
+        if (parent === null) {
+            return [];
+        }
+        // scoped to the parent's own page, so a route that prefixes another cannot claim its chunks
+        return chunks.filter((chunk) => chunk.route === parent.route &&
+            (chunk.id.startsWith(`${parent.id}/`) ||
+                chunk.id.startsWith(`${parent.id}#`)));
+    };
+    const suggestChunkIds = (id) => {
+        const requested = normalizeRoute(id);
+        const route = requested.split("#")[0];
+        const pageIndex = pageIndexByRoute.get(route);
+        if (pageIndex !== undefined) {
+            return chunks
+                .filter((chunk) => chunk.route === pages[pageIndex].route)
+                .slice(0, NOT_FOUND_SUGGESTION_LIMIT)
+                .map((chunk) => chunk.id);
+        }
+        return (chunks
+            .map((chunk) => ({
+            id: chunk.id,
+            overlap: getCommonPrefixLength(chunk.id.toLowerCase(), requested),
+        }))
+            .filter((candidate) => candidate.overlap > 0)
+            // codepoint order, never locale order: these keys carry `/`, `#` and `-`
+            .sort((left, right) => {
+            if (right.overlap !== left.overlap) {
+                return right.overlap - left.overlap;
+            }
+            else {
+                return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+            }
+        })
+            .slice(0, NOT_FOUND_SUGGESTION_LIMIT)
+            .map((candidate) => candidate.id));
+    };
+    return {
+        getMeta: () => ({
+            bundledAt: catalog.bundledAt,
+            siteBaseUrl: catalog.siteBaseUrl,
+            totalPageCount: pages.length,
+            totalChunkCount: chunks.length,
+        }),
+        search,
+        getChunkById,
+        getPageByRoute: (route) => {
+            const index = pageIndexByRoute.get(normalizeRoute(route));
+            return index === undefined ? null : pages[index];
+        },
+        getChildChunks,
+        suggestChunkIds,
+        listSections: () => [...sections].sort(),
+        listTabs: () => [...tabs].sort(),
+    };
+};
+const docsCatalogLoader = memoizeCatalogLoader(() => {
+    const catalogPath = join(getMcpPackageDirectory(), DOCS_CATALOG_FILE_NAME);
+    const rawCatalog = readFileSync(catalogPath, "utf8");
+    return createDocsCatalogStore(parseDocsCatalog(JSON.parse(rawCatalog)));
+});
+export const loadDocsCatalog = () => {
+    return docsCatalogLoader.load();
+};
+export const getOrLoadDocsStore = () => {
+    return docsCatalogLoader.getOrLoad();
+};