specra 0.2.6 → 0.2.8

package/dist/config.server.js

@@ -151,45 +151,68 @@ export function reloadConfig(userConfig) {
  */
 const versionConfigCache = new Map();
 const VCFG_TTL = process.env.NODE_ENV === 'development' ? 5000 : 60000;
-export function loadVersionConfig(version) {
-    const cached = versionConfigCache.get(version);
+export function loadVersionConfig(version, product) {
+    const cacheKey = product && product !== "_default_" ? `${product}:${version}` : version;
+    const cached = versionConfigCache.get(cacheKey);
     if (cached && Date.now() - cached.timestamp < VCFG_TTL) {
         return cached.data;
     }
     try {
-        const versionConfigPath = path.join(process.cwd(), "docs", version, "_version_.json");
+        const basePath = (product && product !== "_default_")
+            ? path.join(process.cwd(), "docs", product, version)
+            : path.join(process.cwd(), "docs", version);
+        const versionConfigPath = path.join(basePath, "_version_.json");
         if (!fs.existsSync(versionConfigPath)) {
-            versionConfigCache.set(version, { data: null, timestamp: Date.now() });
+            versionConfigCache.set(cacheKey, { data: null, timestamp: Date.now() });
             return null;
         }
         const content = fs.readFileSync(versionConfigPath, "utf8");
         const data = JSON.parse(content);
-        versionConfigCache.set(version, { data, timestamp: Date.now() });
+        versionConfigCache.set(cacheKey, { data, timestamp: Date.now() });
         return data;
     }
     catch (error) {
-        console.error(`Error loading _version_.json for ${version}:`, error);
-        versionConfigCache.set(version, { data: null, timestamp: Date.now() });
+        console.error(`Error loading _version_.json for ${cacheKey}:`, error);
+        versionConfigCache.set(cacheKey, { data: null, timestamp: Date.now() });
         return null;
     }
 }
 /**
- * Get the effective config for a specific version.
- * Merges global config with per-version overrides from _version_.json.
- * If no _version_.json exists, returns the global config unchanged.
+ * Get the effective config for a specific version and optional product.
+ * Merges in priority order: global ← product ← version.
+ * If no overrides exist, returns the global config unchanged.
  */
-export function getEffectiveConfig(version) {
+export function getEffectiveConfig(version, product) {
     const globalConfig = getConfig();
-    const versionConfig = loadVersionConfig(version);
-    if (!versionConfig) {
-        return globalConfig;
-    }
-    const effective = { ...globalConfig };
-    if (versionConfig.tabGroups !== undefined) {
-        effective.navigation = {
-            ...effective.navigation,
-            tabGroups: versionConfig.tabGroups,
-        };
+    let effective = { ...globalConfig };
+    // Layer 2: Product config overrides
+    if (product && product !== "_default_") {
+        const productConfig = loadProductConfig(product);
+        if (productConfig) {
+            if (productConfig.tabGroups !== undefined) {
+                effective.navigation = {
+                    ...effective.navigation,
+                    tabGroups: productConfig.tabGroups,
+                };
+            }
+            // Product's activeVersion overrides global
+            if (productConfig.activeVersion) {
+                effective.site = {
+                    ...effective.site,
+                    activeVersion: productConfig.activeVersion,
+                };
+            }
+        }
+    }
+    // Layer 3: Version config overrides (highest priority)
+    const versionConfig = loadVersionConfig(version, product);
+    if (versionConfig) {
+        if (versionConfig.tabGroups !== undefined) {
+            effective.navigation = {
+                ...effective.navigation,
+                tabGroups: versionConfig.tabGroups,
+            };
+        }
     }
     return effective;
 }
@@ -197,9 +220,9 @@ export function getEffectiveConfig(version) {
  * Get metadata for all versions, enriched with _version_.json data.
  * Hidden versions are included but marked — the UI decides whether to show them.
  */
-export function getVersionsMeta(versions) {
+export function getVersionsMeta(versions, product) {
     return versions.map(id => {
-        const versionConfig = loadVersionConfig(id);
+        const versionConfig = loadVersionConfig(id, product);
         return {
             id,
             label: versionConfig?.label || id,
@@ -209,6 +232,145 @@ export function getVersionsMeta(versions) {
         };
     });
 }
+// ─── Product Detection & Loading ─────────────────────────────────────────────
+/** Regex to detect version-like directory names (e.g., v1, v2.0.0) */
+const VERSION_PATTERN = /^v\d/;
+/** Cache for product scanning */
+const productsCache = {
+    data: null,
+    timestamp: 0,
+};
+const PCFG_TTL = process.env.NODE_ENV === 'development' ? 5000 : 60000;
+/** Cache for individual product configs */
+const productConfigCache = new Map();
+/**
+ * Load and parse a _product_.json file for a given product slug.
+ * Returns null if the file doesn't exist or is invalid.
+ */
+export function loadProductConfig(product) {
+    const cached = productConfigCache.get(product);
+    if (cached && Date.now() - cached.timestamp < PCFG_TTL) {
+        return cached.data;
+    }
+    try {
+        const productConfigPath = path.join(process.cwd(), "docs", product, "_product_.json");
+        if (!fs.existsSync(productConfigPath)) {
+            productConfigCache.set(product, { data: null, timestamp: Date.now() });
+            return null;
+        }
+        const content = fs.readFileSync(productConfigPath, "utf8");
+        const data = JSON.parse(content);
+        if (!data.label) {
+            console.error(`[Specra] _product_.json in docs/${product}/ is missing required "label" field`);
+            productConfigCache.set(product, { data: null, timestamp: Date.now() });
+            return null;
+        }
+        productConfigCache.set(product, { data, timestamp: Date.now() });
+        return data;
+    }
+    catch (error) {
+        console.error(`[Specra] Error loading _product_.json for ${product}:`, error);
+        productConfigCache.set(product, { data: null, timestamp: Date.now() });
+        return null;
+    }
+}
+/**
+ * Scan docs/ top-level directories for _product_.json files.
+ * Returns the full list of products including the default product.
+ *
+ * Detection logic:
+ * 1. Single readdir + stat calls — no recursive walks
+ * 2. If no _product_.json found → single-product mode (returns empty array)
+ * 3. If any found → multi-product mode; bare version folders become the default product
+ * 4. Product slugs that match version patterns (e.g., v1.0.0) are rejected with a clear error
+ */
+export function scanProducts() {
+    if (productsCache.data && Date.now() - productsCache.timestamp < PCFG_TTL) {
+        return productsCache.data;
+    }
+    const docsDir = path.join(process.cwd(), "docs");
+    const products = [];
+    let hasExplicitProducts = false;
+    try {
+        const entries = fs.readdirSync(docsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const productJsonPath = path.join(docsDir, entry.name, "_product_.json");
+            if (!fs.existsSync(productJsonPath))
+                continue;
+            // Validate: product slugs must not look like version names
+            if (VERSION_PATTERN.test(entry.name)) {
+                console.error(`[Specra] Invalid product directory "docs/${entry.name}/": ` +
+                    `product slugs must not start with "v" followed by digits (looks like a version). ` +
+                    `Rename the directory or remove _product_.json.`);
+                continue;
+            }
+            const config = loadProductConfig(entry.name);
+            if (config) {
+                hasExplicitProducts = true;
+                products.push({
+                    slug: entry.name,
+                    config,
+                    isDefault: false,
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error("[Specra] Error scanning for products:", error);
+    }
+    // Only build a product list if explicit products were found
+    if (!hasExplicitProducts) {
+        productsCache.data = [];
+        productsCache.timestamp = Date.now();
+        return [];
+    }
+    // Add the default product (bare version folders)
+    const globalConfig = getConfig();
+    const defaultProductConfig = globalConfig.site?.defaultProduct;
+    const defaultProduct = {
+        slug: "_default_",
+        config: {
+            label: defaultProductConfig?.label || globalConfig.site?.title || "Docs",
+            icon: defaultProductConfig?.icon,
+            activeVersion: defaultProductConfig?.activeVersion || globalConfig.site?.activeVersion,
+            position: -1, // Default product always first
+        },
+        isDefault: true,
+    };
+    const allProducts = [defaultProduct, ...products];
+    // Sort by position (lower first), then alphabetically by label
+    allProducts.sort((a, b) => {
+        const posA = a.config.position ?? 999;
+        const posB = b.config.position ?? 999;
+        if (posA !== posB)
+            return posA - posB;
+        return a.config.label.localeCompare(b.config.label);
+    });
+    productsCache.data = allProducts;
+    productsCache.timestamp = Date.now();
+    return allProducts;
+}
+/**
+ * Get all products (cached). Returns empty array in single-product mode.
+ */
+export function getProducts() {
+    return scanProducts();
+}
+/**
+ * Check if the site is in multi-product mode.
+ */
+export function isMultiProductMode() {
+    return getProducts().length > 0;
+}
+/**
+ * Clear product-related caches. Called by file watchers when _product_.json changes.
+ */
+export function clearProductCaches() {
+    productsCache.data = null;
+    productConfigCache.clear();
+}
 /**
  * Export the loaded config as default (SERVER ONLY)
  */

package/dist/config.types.d.ts

@@ -34,6 +34,8 @@ export interface SiteConfig {
     hideLogo?: boolean;
     /** Project ID to tie this doc site to a Specra project for visitor tracking */
     projectId?: string;
+    /** Configuration for the default product in multi-product mode */
+    defaultProduct?: DefaultProductConfig;
 }
 /**
  * Theme and appearance settings
@@ -84,6 +86,50 @@ export interface VersionConfig {
     /** Override tab groups for this version. Empty array = no tabs. */
     tabGroups?: TabGroup[];
 }
+/**
+ * Per-product configuration loaded from docs/{product}/_product_.json
+ * Products sit above versions in the config hierarchy.
+ */
+export interface ProductConfig {
+    /** Display name in the product switcher */
+    label: string;
+    /** Icon identifier for the product dropdown (lucide icon name) */
+    icon?: string;
+    /** Short description of the product */
+    description?: string;
+    /** Default version for this product (overrides global site.activeVersion) */
+    activeVersion?: string;
+    /** Badge text shown next to the product (e.g., "New", "Beta") */
+    badge?: string;
+    /** Order in the product dropdown (lower = first) */
+    position?: number;
+    /** Product-level tab group overrides */
+    tabGroups?: TabGroup[];
+}
+/**
+ * Resolved product with its slug and metadata.
+ * Returned by getProducts() — includes both filesystem identity and parsed config.
+ */
+export interface Product {
+    /** Filesystem directory name used in URLs (e.g., "api", "sdk") */
+    slug: string;
+    /** Parsed product configuration from _product_.json */
+    config: ProductConfig;
+    /** Whether this is the default product (bare version folders, no _product_.json) */
+    isDefault: boolean;
+}
+/**
+ * Default product configuration in specra.config.json under site.defaultProduct.
+ * Used when the default product needs a custom label/icon instead of inheriting from site title.
+ */
+export interface DefaultProductConfig {
+    /** Display name for the default product in the switcher */
+    label?: string;
+    /** Icon for the default product */
+    icon?: string;
+    /** Override active version for the default product */
+    activeVersion?: string;
+}
 /**
  * Navigation and sidebar configuration
  */

package/dist/mdx-cache.d.ts

@@ -6,18 +6,15 @@
  * invalidated automatically when files change.
  */
 import type { Doc } from './mdx';
-/**
- * Cached version of getVersions()
- */
-export declare function getCachedVersions(): string[];
+export declare function getCachedVersions(product?: string): string[];
 /**
  * Cached version of getAllDocs()
  */
-export declare function getCachedAllDocs(version?: string, locale?: string): Promise<Doc[]>;
+export declare function getCachedAllDocs(version?: string, locale?: string, product?: string): Promise<Doc[]>;
 /**
  * Cached version of getDocBySlug()
  */
-export declare function getCachedDocBySlug(slug: string, version?: string): Promise<Doc | null>;
+export declare function getCachedDocBySlug(slug: string, version?: string, product?: string): Promise<Doc | null>;
 /**
  * Manually clear all caches
  * Useful for testing or when you want to force a refresh

package/dist/mdx-cache.js

@@ -6,6 +6,7 @@
  * invalidated automatically when files change.
  */
 import { getVersions, getAllDocs, getDocBySlug } from './mdx';
+import { clearProductCaches } from './config.server';
 import { watch } from 'fs';
 import { join } from 'path';
 import { PerfTimer, logCacheOperation } from './dev-utils';
@@ -36,6 +37,11 @@ function initializeWatchers() {
                 return;
             // Invalidate relevant caches when MDX or JSON files change
             if (filename.endsWith('.mdx') || filename.endsWith('.json')) {
+                // Clear product caches when _product_.json changes
+                if (filename.endsWith('_product_.json')) {
+                    clearProductCaches();
+                    console.log(`[MDX Cache] Product cache invalidated: ${filename}`);
+                }
                 // Extract version from path
                 const parts = filename.split(/[/\\]/);
                 const version = parts[0];
@@ -52,6 +58,7 @@ function initializeWatchers() {
                 // Clear versions cache if directory structure changed
                 if (eventType === 'rename') {
                     versionsCache.data = null;
+                    clearProductCaches();
                 }
                 console.log(`[MDX Cache] Invalidated cache for: ${filename}`);
             }
@@ -69,11 +76,28 @@ function isCacheValid(timestamp) {
     return Date.now() - timestamp < CACHE_TTL;
 }
 /**
- * Cached version of getVersions()
+ * Cached version of getVersions().
+ * When product is provided, uses a separate cache key per product.
  */
-export function getCachedVersions() {
+const productVersionsCache = new Map();
+export function getCachedVersions(product) {
     // Initialize watchers on first use
     initializeWatchers();
+    // For product-scoped versions, use a separate cache
+    if (product && product !== "_default_") {
+        const cached = productVersionsCache.get(product);
+        if (cached && isCacheValid(cached.timestamp)) {
+            logCacheOperation('hit', `versions:${product}`);
+            return cached.data;
+        }
+        logCacheOperation('miss', `versions:${product}`);
+        const timer = new PerfTimer(`getVersions(${product})`);
+        const versions = getVersions(product);
+        timer.end();
+        productVersionsCache.set(product, { data: versions, timestamp: Date.now() });
+        return versions;
+    }
+    // Default product — original cache
     if (versionsCache.data && isCacheValid(versionsCache.timestamp)) {
         logCacheOperation('hit', 'versions');
         return versionsCache.data;
@@ -89,10 +113,11 @@ export function getCachedVersions() {
 /**
  * Cached version of getAllDocs()
  */
-export async function getCachedAllDocs(version = 'v1.0.0', locale) {
+export async function getCachedAllDocs(version = 'v1.0.0', locale, product) {
     // Initialize watchers on first use
     initializeWatchers();
-    const cacheKey = locale ? `${version}:${locale}` : version;
+    const productKey = (product && product !== "_default_") ? product : "_default_";
+    const cacheKey = locale ? `${productKey}:${version}:${locale}` : `${productKey}:${version}`;
     const cached = allDocsCache.get(cacheKey);
     if (cached && isCacheValid(cached.timestamp)) {
         logCacheOperation('hit', `getAllDocs:${cacheKey}`);
@@ -100,7 +125,7 @@ export async function getCachedAllDocs(version = 'v1.0.0', locale) {
     }
     logCacheOperation('miss', `getAllDocs:${cacheKey}`);
     const timer = new PerfTimer(`getAllDocs(${cacheKey})`);
-    const docs = await getAllDocs(version, locale);
+    const docs = await getAllDocs(version, locale, product);
     timer.end();
     allDocsCache.set(cacheKey, {
         data: docs,
@@ -111,10 +136,11 @@ export async function getCachedAllDocs(version = 'v1.0.0', locale) {
 /**
  * Cached version of getDocBySlug()
  */
-export async function getCachedDocBySlug(slug, version = 'v1.0.0') {
+export async function getCachedDocBySlug(slug, version = 'v1.0.0', product) {
     // Initialize watchers on first use
     initializeWatchers();
-    const cacheKey = `${version}:${slug}`;
+    const productKey = (product && product !== "_default_") ? product : "_default_";
+    const cacheKey = `${productKey}:${version}:${slug}`;
     const cached = docBySlugCache.get(cacheKey);
     if (cached && isCacheValid(cached.timestamp)) {
         logCacheOperation('hit', `getDocBySlug:${cacheKey}`);
@@ -122,7 +148,7 @@ export async function getCachedDocBySlug(slug, version = 'v1.0.0') {
     }
     logCacheOperation('miss', `getDocBySlug:${cacheKey}`);
     const timer = new PerfTimer(`getDocBySlug(${slug})`);
-    const doc = await getDocBySlug(slug, version);
+    const doc = await getDocBySlug(slug, version, undefined, product);
     timer.end();
     docBySlugCache.set(cacheKey, {
         data: doc,
@@ -136,8 +162,10 @@ export async function getCachedDocBySlug(slug, version = 'v1.0.0') {
  */
 export function clearAllCaches() {
     versionsCache.data = null;
+    productVersionsCache.clear();
     allDocsCache.clear();
     docBySlugCache.clear();
+    clearProductCaches();
     console.log('[MDX Cache] All caches cleared');
 }
 /**

package/dist/mdx.d.ts

@@ -58,10 +58,15 @@ export interface TocItem {
     title: string;
     level: number;
 }
-export declare function getVersions(): string[];
+export declare function getVersions(product?: string): string[];
+/**
+ * Get versions scoped to a specific product.
+ * Convenience wrapper around getVersions() for product-aware code.
+ */
+export declare function getProductVersions(product: string): string[];
 export declare function getI18nConfig(): I18nConfig | null;
-export declare function getDocBySlug(slug: string, version?: string, locale?: string): Promise<Doc | null>;
-export declare function getAllDocs(version?: string, locale?: string): Doc[];
+export declare function getDocBySlug(slug: string, version?: string, locale?: string, product?: string): Promise<Doc | null>;
+export declare function getAllDocs(version?: string, locale?: string, product?: string): Doc[];
 export declare function getAdjacentDocs(currentSlug: string, allDocs: Doc[]): {
     previous?: Doc;
     next?: Doc;

package/dist/mdx.js

@@ -16,6 +16,17 @@ import { sortSidebarItems, sortSidebarGroups, buildSidebarStructure } from "./si
 import { sanitizePath, validatePathWithinDirectory, validateMDXSecurity } from "./mdx-security";
 import { getConfig } from "./config";
 const DOCS_DIR = path.join(process.cwd(), "docs");
+/**
+ * Resolve the docs directory for a given version and optional product.
+ * - Default product or omitted: docs/{version}/
+ * - Named product: docs/{product}/{version}/
+ */
+function resolveDocsPath(version, product) {
+    if (product && product !== "_default_") {
+        return path.join(DOCS_DIR, product, version);
+    }
+    return path.join(DOCS_DIR, version);
+}
 /**
  * Map of lowercased HTML tag names to PascalCase component names.
  * When rehype processes MDX, it lowercases all custom tags.
@@ -368,7 +379,14 @@ function parseJsxExpression(expr) {
             return JSON.parse(trimmed);
         }
         catch {
-            return trimmed;
+            // Convert JS object notation inside arrays to JSON
+            const jsonStr = trimmed.replace(/(\w+)\s*:/g, '"$1":').replace(/:\s*'([^']*)'/g, ': "$1"');
+            try {
+                return JSON.parse(jsonStr);
+            }
+            catch {
+                return trimmed;
+            }
         }
     }
     return trimmed;
@@ -438,6 +456,61 @@ function extractCodeBlockProps(node) {
     const filename = node.properties?.['data-filename'] || codeChild.properties?.['data-filename'];
     return { code, language, ...(filename ? { filename } : {}) };
 }
+/**
+ * Detect GitHub-style alert blockquotes: > [!WARNING] content
+ * Returns the alert type and remaining content children, or null if not an alert.
+ */
+const ALERT_TYPE_MAP = {
+    NOTE: 'note',
+    TIP: 'tip',
+    IMPORTANT: 'info',
+    WARNING: 'warning',
+    CAUTION: 'danger',
+    INFO: 'info',
+    SUCCESS: 'success',
+    ERROR: 'error',
+    DANGER: 'danger',
+};
+function extractBlockquoteAlert(node) {
+    if (node.type !== 'element' || node.tagName !== 'blockquote')
+        return null;
+    if (!node.children || node.children.length === 0)
+        return null;
+    // Find the first paragraph child
+    const firstP = node.children.find((c) => c.type === 'element' && c.tagName === 'p');
+    if (!firstP || !firstP.children || firstP.children.length === 0)
+        return null;
+    // Check first text node for [!TYPE] pattern
+    const firstText = firstP.children[0];
+    if (firstText.type !== 'text')
+        return null;
+    const match = firstText.value.match(/^\s*\[!(\w+)\]\s*\n?/);
+    if (!match)
+        return null;
+    const alertType = ALERT_TYPE_MAP[match[1].toUpperCase()];
+    if (!alertType)
+        return null;
+    // Build remaining content: modify the first paragraph to remove the alert marker
+    const remainingFirstPChildren = [...firstP.children];
+    const remainingText = firstText.value.slice(match[0].length);
+    if (remainingText.trim()) {
+        remainingFirstPChildren[0] = { ...firstText, value: remainingText };
+    }
+    else {
+        remainingFirstPChildren.shift();
+    }
+    const contentChildren = [];
+    if (remainingFirstPChildren.length > 0) {
+        contentChildren.push({ ...firstP, children: remainingFirstPChildren });
+    }
+    // Add any remaining blockquote children (paragraphs after the first)
+    for (const child of node.children) {
+        if (child !== firstP) {
+            contentChildren.push(child);
+        }
+    }
+    return { type: alertType, contentChildren };
+}
 /**
  * Recursively extract text content from a hast node.
  */
@@ -709,6 +782,20 @@ async function hastChildrenToMdxNodes(children) {
                 children: childNodes,
             });
         }
+        else if (extractBlockquoteAlert(child)) {
+            // GitHub-style alert blockquotes: > [!WARNING] content
+            flushHtmlBuffer();
+            const alert = extractBlockquoteAlert(child);
+            const contentNodes = alert.contentChildren.length > 0
+                ? await hastChildrenToMdxNodes(alert.contentChildren)
+                : [];
+            nodes.push({
+                type: 'component',
+                name: 'Callout',
+                props: { type: alert.type },
+                children: contentNodes,
+            });
+        }
         else {
             // Check if this regular element contains any component elements nested within
             if (hasNestedComponent(child)) {
@@ -981,15 +1068,35 @@ function calculateReadingTime(content) {
     const minutes = Math.ceil(words / 200);
     return { minutes, words };
 }
-export function getVersions() {
+export function getVersions(product) {
     try {
-        const versions = fs.readdirSync(DOCS_DIR);
-        return versions.filter((v) => fs.statSync(path.join(DOCS_DIR, v)).isDirectory());
+        const baseDir = (product && product !== "_default_")
+            ? path.join(DOCS_DIR, product)
+            : DOCS_DIR;
+        const entries = fs.readdirSync(baseDir);
+        return entries.filter((v) => {
+            if (!fs.statSync(path.join(baseDir, v)).isDirectory())
+                return false;
+            // In the default product's base dir, skip product directories (those with _product_.json)
+            if (!product || product === "_default_") {
+                const hasProductJson = fs.existsSync(path.join(baseDir, v, "_product_.json"));
+                if (hasProductJson)
+                    return false;
+            }
+            return true;
+        });
     }
     catch (error) {
         return ["v1.0.0"];
     }
 }
+/**
+ * Get versions scoped to a specific product.
+ * Convenience wrapper around getVersions() for product-aware code.
+ */
+export function getProductVersions(product) {
+    return getVersions(product);
+}
 /**
  * Recursively find all MDX files in a directory
  */
@@ -1094,7 +1201,7 @@ export function getI18nConfig() {
     }
     return i18n;
 }
-export async function getDocBySlug(slug, version = "v1.0.0", locale) {
+export async function getDocBySlug(slug, version = "v1.0.0", locale, product) {
     try {
         // Security: Sanitize and validate slug
         const sanitizedVersion = sanitizePath(version);
@@ -1117,8 +1224,8 @@ export async function getDocBySlug(slug, version = "v1.0.0", locale) {
         // Try finding the file in this order:
         // 1. Localized extension: slug.locale.mdx (e.g. guide.fr.mdx)
         // 2. Default file: slug.mdx (only if using default locale and configured to fallback or strictly default)
-        // Construct potential paths
-        const basePath = path.join(DOCS_DIR, sanitizedVersion);
+        // Construct potential paths — product-aware
+        const basePath = resolveDocsPath(sanitizedVersion, product);
         let result = null;
         // 1. Try localized file extension
         if (targetLocale) {
@@ -1156,9 +1263,9 @@ export async function getDocBySlug(slug, version = "v1.0.0", locale) {
         return null;
     }
 }
-export function getAllDocs(version = "v1.0.0", locale) {
+export function getAllDocs(version = "v1.0.0", locale, product) {
     try {
-        const versionDir = path.join(DOCS_DIR, version);
+        const versionDir = resolveDocsPath(version, product);
         if (!fs.existsSync(versionDir)) {
             return [];
         }
@@ -1166,7 +1273,7 @@ export function getAllDocs(version = "v1.0.0", locale) {
         const i18nConfig = getI18nConfig();
         const targetLocale = locale || i18nConfig?.defaultLocale || 'en';
         const mdxFiles = findMdxFiles(versionDir);
-        const categoryConfigs = getAllCategoryConfigs(version);
+        const categoryConfigs = getAllCategoryConfigs(version, product);
         const docs = mdxFiles.map((file) => {
             // file contains path relative to version dir, e.g. "getting-started/intro.mdx" or "intro.fr.mdx"
             let originalFilePath = file.replace(/\.mdx$/, "");

package/dist/parsers/openapi-parser.js

@@ -116,8 +116,13 @@ export class OpenApiParser {
     parseParameters(parameters, spec) {
         const result = { path: [], query: [], header: [] };
         for (const param of parameters) {
+            if (!param)
+                continue;
             // Resolve $ref if present
             const resolved = param.$ref ? this.resolveRef(param.$ref, spec) : param;
+            // Skip params that failed to resolve or have no name
+            if (!resolved || !resolved.name || !resolved.in)
+                continue;
             const apiParam = {
                 name: resolved.name,
                 type: resolved.schema?.type || resolved.type || "string",
@@ -202,7 +207,7 @@ export class OpenApiParser {
         for (const segment of path) {
             current = current[segment];
             if (!current)
-                return {};
+                return null;
         }
         return current;
     }