@mintlify/common 1.0.1170 → 1.0.1172

package/dist/asyncapi/validateAsyncApi.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Parser } from '@asyncapi/parser';
+import { DiagnosticSeverity, Parser } from '@asyncapi/parser';
 import { checkForExternalRefs } from './checkForExternalRefs.js';
 export function validateAsyncApi(str) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -16,11 +16,18 @@ export function validateAsyncApi(str) {
             checkForExternalRefs(str);
             const parser = new Parser();
             const { document, diagnostics } = yield parser.parse(str);
-            if (diagnostics.length > 0) {
-                const errorMessages = diagnostics.map((diagnostic) => diagnostic.message).join('\n');
+            const errors = diagnostics.filter((diagnostic) => diagnostic.severity === DiagnosticSeverity.Error);
+            if (!document || errors.length > 0) {
                 return {
                     valid: false,
-                    errorMessage: errorMessages,
+                    errorMessage: errors.map((diagnostic) => diagnostic.message).join('\n'),
+                    document: undefined,
+                };
+            }
+            if (!document.version().startsWith('3.')) {
+                return {
+                    valid: false,
+                    errorMessage: `AsyncAPI ${document.version()} is not supported. Please use AsyncAPI 3.0.0.`,
                     document: undefined,
                 };
             }

package/dist/navigation/scopeNavToPath.js

@@ -1,3 +1,14 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { locales } from '@mintlify/models';
 import { generatePathToLanguageDict, generatePathToVersionDict } from '../divisions/index.js';
 import { optionallyRemoveLeadingSlash } from '../fs/optionallySlash.js';
@@ -157,7 +168,10 @@ function divisionValue(division, key) {
 function resolveStubTarget(division, key, ctx, usePrecomputedTarget) {
     const targets = key === 'versions' ? ctx.versionTargets : ctx.languageTargets;
     const value = divisionValue(division, key);
-    const resolved = usePrecomputedTarget ? targets === null || targets === void 0 ? void 0 : targets.get(value) : undefined;
+    const precomputed = usePrecomputedTarget ? targets === null || targets === void 0 ? void 0 : targets.get(value) : undefined;
+    const resolved = precomputed && divisionContainsPath(division, precomputed.href) ? precomputed : undefined;
+    if (precomputed && !resolved)
+        return resolveVisibleTarget(division, ctx);
     const fallback = pickStubTarget(division, ctx, DIVISION_TYPE_BY_KEY[key]);
     // the jump-map walk records targets without access checks, so a precomputed
     // entry only supplies the switch destination; hidden/groups still come from
@@ -204,19 +218,22 @@ function simpleDivisionLabel(division, key) {
 // client's stateful dropdownCache hrefs, and the active product is client
 // session state — divisions containing any of them stay whole
 const STATEFUL_DIVISION_KEYS = new Set(['versions', 'languages', 'dropdowns', 'products']);
-function containsStatefulDivision(node) {
+function containsDivision(node, keys) {
     if (Array.isArray(node))
-        return node.some(containsStatefulDivision);
+        return node.some((entry) => containsDivision(entry, keys));
     if (!isNavNode(node))
         return false;
     for (const [key, value] of Object.entries(node)) {
-        if (STATEFUL_DIVISION_KEYS.has(key) && Array.isArray(value))
+        if (keys.has(key) && Array.isArray(value))
             return true;
-        if ((Array.isArray(value) || isNavNode(value)) && containsStatefulDivision(value))
+        if ((Array.isArray(value) || isNavNode(value)) && containsDivision(value, keys))
             return true;
     }
     return false;
 }
+const containsStatefulDivision = (node) => containsDivision(node, STATEFUL_DIVISION_KEYS);
+const PRODUCT_KEYS = new Set(['products']);
+const containsProducts = (node) => containsDivision(node, PRODUCT_KEYS);
 // mirrors buildDivisionItem's anonymous href resolution (first page in
 // getFirstPageFromNavigation order that is neither hidden nor group-gated);
 // falls back to the first raw candidate so a division with no anonymously
@@ -244,6 +261,40 @@ function hasViewerVisiblePage(node, ctx) {
     node, (_a = ctx.userGroups) !== null && _a !== void 0 ? _a : new Set(), true, ctx.isPreview === true) !== undefined);
 }
 const MENU_STUBBABLE_KEYS = new Set(['pages', 'groups']);
+const NODE_LABEL_KEYS = ['version', 'language', 'dropdown', 'tab', 'anchor', 'item'];
+function nodeLabel(node) {
+    for (const key of NODE_LABEL_KEYS) {
+        if (typeof node[key] === 'string')
+            return node[key];
+    }
+    return '';
+}
+const isContainerKey = (key) => CONTAINER_KEYS.some((containerKey) => containerKey === key);
+function stubPageList(key, entries, label, ctx) {
+    const target = resolveVisibleTarget({ [key]: entries }, ctx);
+    if (!target)
+        return entries;
+    const page = target.isRaw ? target.href : makeStubPage(label, target);
+    return key === 'pages' ? [page] : [{ group: label, pages: [page] }];
+}
+function skeletonStub(node, ctx) {
+    if (typeof node.href === 'string')
+        return node;
+    const label = nodeLabel(node);
+    const stub = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (Array.isArray(value) && isContainerKey(key)) {
+            stub[key] = value.map((entry) => (isNavNode(entry) ? skeletonStub(entry, ctx) : entry));
+        }
+        else if (Array.isArray(value) && (key === 'pages' || key === 'groups')) {
+            stub[key] = stubPageList(key, value, label, ctx);
+        }
+        else {
+            stub[key] = value;
+        }
+    }
+    return stub;
+}
 // inactive tabs/products still render their full hover menu, so menu items
 // survive stubbing with their metadata and a single resolved page each
 function stubMenuItem(item, ctx) {
@@ -252,9 +303,10 @@ function stubMenuItem(item, ctx) {
     if (typeof item.href === 'string')
         return item;
     const subtreeKeys = Object.keys(item).filter((key) => STUB_STRIPPED_KEYS.has(key));
-    if (!subtreeKeys.length || !subtreeKeys.every((key) => MENU_STUBBABLE_KEYS.has(key))) {
+    if (!subtreeKeys.length || containsProducts(item))
         return scopeNode(item, ctx);
-    }
+    if (subtreeKeys.some((key) => !MENU_STUBBABLE_KEYS.has(key)))
+        return skeletonStub(item, ctx);
     const target = resolveVisibleTarget(item, ctx);
     if (!target)
         return item;
@@ -272,7 +324,8 @@ function stubMenuItem(item, ctx) {
 function stubSimpleDivision(division, key, ctx) {
     if (typeof division.href === 'string')
         return division;
-    if (containsStatefulDivision(division))
+    const { menu } = division, rest = __rest(division, ["menu"]);
+    if (containsStatefulDivision(rest) || containsProducts(menu))
         return scopeNode(division, ctx);
     const target = resolveVisibleTarget(division, ctx);
     if (!target)
@@ -291,36 +344,30 @@ function stubSimpleDivision(division, key, ctx) {
         : [makeStubPage(simpleDivisionLabel(division, key), target)];
     return stub;
 }
-function scopeSimpleDivisionArray(entries, key, ctx) {
-    const activeIndex = entries.findIndex((entry) => isNavNode(entry) && divisionContainsPath(entry, ctx.currentPath));
+function scopeSiblingArray(entries, ctx, stub) {
+    const containsPath = entries.map((entry) => isNavNode(entry) && divisionContainsPath(entry, ctx.currentPath));
     // when the path-containing division is invisible to the viewer (hidden-only
     // or group-gated), the client's active-division fallback lands on a sibling
     // instead — that sibling must keep its real subtree, so nothing is stubbed
-    const activeEntry = activeIndex === -1 ? undefined : entries[activeIndex];
-    const activeVisible = isNavNode(activeEntry) && hasViewerVisiblePage(activeEntry, ctx);
+    const allContainingVisible = entries.every((entry, index) => !containsPath[index] || (isNavNode(entry) && hasViewerVisiblePage(entry, ctx)));
+    const canStub = containsPath.some(Boolean) && allContainingVisible;
     return entries.map((entry, index) => {
         if (!isNavNode(entry))
             return entry;
         // without a path match the active division is unknowable, so nothing is stubbed
-        if (!activeVisible || index === activeIndex)
+        if (!canStub || containsPath[index])
             return scopeNode(entry, ctx);
-        return stubSimpleDivision(entry, key, ctx);
+        return stub(entry);
     });
 }
+function scopeSimpleDivisionArray(entries, key, ctx) {
+    return scopeSiblingArray(entries, ctx, (entry) => stubSimpleDivision(entry, key, ctx));
+}
 // the same collapse applied to stubbed tabs' menus, but inside the active
-// tab/anchor: the item containing the path keeps its subtree (it feeds the
+// tab/anchor: items containing the path keep their subtree (they feed the
 // sidebar), siblings survive as hover-menu metadata plus one resolved page
 function scopeMenuArray(entries, ctx) {
-    const activeIndex = entries.findIndex((entry) => isNavNode(entry) && divisionContainsPath(entry, ctx.currentPath));
-    const activeEntry = activeIndex === -1 ? undefined : entries[activeIndex];
-    const activeVisible = isNavNode(activeEntry) && hasViewerVisiblePage(activeEntry, ctx);
-    return entries.map((entry, index) => {
-        if (!isNavNode(entry))
-            return entry;
-        if (!activeVisible || index === activeIndex)
-            return scopeNode(entry, ctx);
-        return stubMenuItem(entry, ctx);
-    });
+    return scopeSiblingArray(entries, ctx, (entry) => stubMenuItem(entry, ctx));
 }
 function scopeDivisionArray(entries, key, ctx) {
     if (ctx.skipVersionLanguageStubs) {

package/dist/navigation/scopeOffPathDivisions.test.js

@@ -1,6 +1,7 @@
+import { locales } from '@mintlify/models';
 import { filterDivisions } from './filterDivisions.js';
 import { getAllPathsInDecoratedNav } from './getAllPathsInDecoratedNav.js';
-import { getScopedNavForPath } from './scopeNavToPath.js';
+import { getScopedNavForPath, scopeDocsConfigNavToPath } from './scopeNavToPath.js';
 const multiTabNav = {
     tabs: [
         {
@@ -459,6 +460,247 @@ const hiddenMenuTabNav = {
         },
     ],
 };
+const autosummary = (base, names) => names.map((name) => ({ title: name, href: `/${base}/_autosummary/${name}` }));
+const productMenuNav = {
+    tabs: [
+        {
+            tab: 'Documentation',
+            menu: [
+                {
+                    item: 'Home',
+                    pages: [{ title: 'Home', href: '/home' }],
+                },
+                {
+                    item: 'Engine',
+                    versions: [
+                        {
+                            version: 'v3',
+                            default: true,
+                            dropdowns: [
+                                {
+                                    dropdown: 'Overview',
+                                    groups: [
+                                        {
+                                            group: 'Start',
+                                            pages: [
+                                                { title: 'Engine', href: '/engine/v3/overview' },
+                                                { title: 'Install', href: '/engine/v3/install' },
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    dropdown: 'Python API',
+                                    groups: [
+                                        {
+                                            group: 'Engine',
+                                            pages: autosummary('engine/v3/py', ['Engine.a', 'Engine.b']),
+                                        },
+                                        {
+                                            group: 'Part',
+                                            pages: autosummary('engine/v3/py', ['Part.a', 'Part.b']),
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            version: 'v2',
+                            groups: [
+                                {
+                                    group: 'Overview',
+                                    pages: [
+                                        { title: 'Engine v2', href: '/engine/v2/overview' },
+                                        ...autosummary('engine/v2', ['Engine.a', 'Engine.b']),
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    item: 'Studio',
+                    versions: [
+                        {
+                            version: 'v3',
+                            default: true,
+                            dropdowns: [
+                                {
+                                    dropdown: 'Overview',
+                                    groups: [
+                                        {
+                                            group: 'Start',
+                                            pages: [
+                                                {
+                                                    title: 'Draft',
+                                                    href: '/studio/v3/draft',
+                                                    hidden: true,
+                                                },
+                                                { title: 'Studio', href: '/studio/v3/overview' },
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    dropdown: 'API',
+                                    groups: [
+                                        {
+                                            group: 'Model',
+                                            pages: [
+                                                {
+                                                    title: 'Internal',
+                                                    href: '/studio/v3/api/internal',
+                                                    groups: ['staff'],
+                                                },
+                                                ...autosummary('studio/v3/api', ['Model.a', 'Model.b']),
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            version: 'Legacy',
+                            hidden: true,
+                            pages: [{ title: 'Legacy', href: '/studio/legacy/overview' }],
+                        },
+                    ],
+                },
+                {
+                    item: 'Audio',
+                    dropdowns: [
+                        {
+                            dropdown: 'Overview',
+                            pages: [{ title: 'Audio', href: '/audio/overview' }],
+                        },
+                        {
+                            dropdown: 'API',
+                            pages: [
+                                { title: 'API', href: '/audio/api/overview' },
+                                ...autosummary('audio/api', ['Clip.a', 'Clip.b']),
+                            ],
+                        },
+                    ],
+                },
+                {
+                    item: 'Internal',
+                    versions: [
+                        {
+                            version: 'v3',
+                            pages: [
+                                {
+                                    title: 'Runbook',
+                                    href: '/internal/runbook',
+                                    groups: ['staff'],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            tab: 'Knowledge base',
+            pages: [{ title: 'Blog', href: '/blog' }],
+        },
+    ],
+};
+const page = (href) => ({ title: href, href });
+const versionedItem = (item, v3, v2, hidden) => (Object.assign(Object.assign({ item }, (hidden ? { hidden } : {})), { versions: [
+        { version: 'v3', default: true, groups: [{ group: `${item} v3`, pages: v3.map(page) }] },
+        { version: 'v2', groups: [{ group: `${item} v2`, pages: v2.map(page) }] },
+    ] }));
+const crossListedMenuNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            menu: [
+                { item: 'Home', pages: [page('/home')] },
+                versionedItem('Studio', ['/studio/v3/a', '/studio/v3/b'], ['/studio/v2/a', '/shared']),
+                versionedItem('Engine', ['/engine/v3/a', '/shared', '/engine/v3/c'], ['/engine/v2/a']),
+                versionedItem('Solver', ['/solver/v3/a'], ['/solver/v2/a']),
+            ],
+        },
+        { tab: 'Other', pages: [page('/other')] },
+    ],
+};
+const crossListedHiddenMenuNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            menu: [
+                versionedItem('Studio', ['/studio/v3/a'], ['/studio/v2/a', '/shared'], true),
+                versionedItem('Engine', ['/engine/v3/a', '/shared'], ['/engine/v2/a']),
+                versionedItem('Solver', ['/solver/v3/a'], ['/solver/v2/a']),
+            ],
+        },
+    ],
+};
+const crossListedLanguageMenuNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            menu: ['Studio', 'Engine', 'Solver'].map((item) => ({
+                item,
+                languages: [
+                    {
+                        language: 'en',
+                        default: true,
+                        groups: [
+                            {
+                                group: `${item} en`,
+                                pages: [
+                                    page(`/${item.toLowerCase()}/en`),
+                                    ...(item === 'Engine' ? [page('/shared')] : []),
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        language: 'fr',
+                        groups: [
+                            {
+                                group: `${item} fr`,
+                                pages: [
+                                    page(`/${item.toLowerCase()}/fr`),
+                                    ...(item === 'Studio' ? [page('/shared')] : []),
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            })),
+        },
+    ],
+};
+const crossListedPlainMenuNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            menu: [
+                { item: 'Guides', groups: [{ group: 'Guides', pages: [page('/guides/a'), page('/faq')] }] },
+                {
+                    item: 'Reference',
+                    groups: [{ group: 'Reference', pages: [page('/ref/a'), page('/faq')] }],
+                },
+                { item: 'Other', pages: [page('/other/a')] },
+            ],
+        },
+    ],
+};
+const crossListedTabsNav = {
+    tabs: [
+        {
+            tab: 'Studio',
+            menu: [versionedItem('Studio', ['/studio/v3/a'], ['/studio/v2/a', '/shared'])],
+        },
+        {
+            tab: 'Engine',
+            menu: [versionedItem('Engine', ['/engine/v3/a', '/shared'], ['/engine/v2/a'])],
+        },
+        { tab: 'Solver', menu: [versionedItem('Solver', ['/solver/v3/a'], ['/solver/v2/a'])] },
+    ],
+};
 function filterWith(decoratedNav, currentPath, currentVersion, currentLanguage, isPreview = false, userGroups = new Set()) {
     return filterDivisions({
         currentPath,
@@ -502,6 +744,60 @@ function assertChromeInvariantForEveryPath(nav, isPreview = false, userGroups =
         expect(mapHrefs(rescoped.firstHrefInLanguage), currentPath).toEqual(mapHrefs(full.firstHrefInLanguage));
     }
 }
+const toLocale = (value) => locales.find((locale) => locale === value);
+function sessionValuesContaining(node, href, key, current) {
+    const found = new Set();
+    if (Array.isArray(node)) {
+        for (const entry of node)
+            sessionValuesContaining(entry, href, key, current).forEach((v) => found.add(v));
+        return found;
+    }
+    if (typeof node !== 'object' || node === null)
+        return found;
+    const value = key in node ? Reflect.get(node, key) : undefined;
+    const scope = typeof value === 'string' ? value : current;
+    if (Reflect.get(node, 'href') === href)
+        found.add(scope);
+    for (const child of Object.values(node)) {
+        if (typeof child === 'object' && child !== null) {
+            sessionValuesContaining(child, href, key, scope).forEach((v) => found.add(v));
+        }
+    }
+    return found;
+}
+function activeChrome(result) {
+    return {
+        tabs: result.tabs.map(({ name, isActive, menu }) => ({
+            name,
+            isActive,
+            menu: menu === null || menu === void 0 ? void 0 : menu.map(({ name: item, isActive: active }) => ({ item, active })),
+        })),
+        versions: result.versions.map(({ name, isActive }) => ({ name, isActive })),
+        languages: result.languages.map(({ name, isActive }) => ({ name, isActive })),
+        dropdowns: result.dropdowns.map(({ name, isActive }) => ({ name, isActive })),
+    };
+}
+function assertChromeInvariantForEverySession(nav, key, isPreview = false, userGroups = new Set()) {
+    for (const path of getAllPathsInDecoratedNav(nav)) {
+        const currentPath = `/${path.replace(/^\//, '')}`;
+        const scoped = getScopedNavForPath({ decoratedNav: nav, currentPath, userGroups, isPreview });
+        const isCrossListed = JSON.stringify(nav).split(`"href":"${currentPath}"`).length > 2;
+        for (const value of sessionValuesContaining(nav, currentPath, key)) {
+            const version = key === 'version' ? value : scoped.currentVersion;
+            const language = key === 'language' ? toLocale(value) : scoped.currentLanguage;
+            const label = `${currentPath} ${key}=${value !== null && value !== void 0 ? value : '-'}`;
+            const full = filterWith(nav, currentPath, version, language, isPreview, userGroups);
+            const rescoped = filterWith(scoped.scopedNav, currentPath, version, language, isPreview, userGroups);
+            expect(rescoped.groupsOrPages, label).toEqual(full.groupsOrPages);
+            if (isCrossListed) {
+                expect(activeChrome(rescoped), label).toEqual(activeChrome(full));
+            }
+            else {
+                expect(chromeSummary(rescoped), label).toEqual(chromeSummary(full));
+            }
+        }
+    }
+}
 function tabByName(nav, name) {
     if (!('tabs' in nav))
         throw new Error('nav has no tabs');
@@ -834,7 +1130,7 @@ describe('active-tab menu scoping', () => {
             pages: [{ title: 'Get started', href: '/db/intro' }],
         });
     });
-    it('keeps menu items containing versions whole and version-stubs inside them', () => {
+    it('reduces menu items containing versions to a skeleton with one page per version', () => {
         const { scopedNav } = getScopedNavForPath({
             decoratedNav: menuWithVersionsTabNav,
             currentPath: '/api/webhooks/events',
@@ -855,7 +1151,7 @@ describe('active-tab menu scoping', () => {
                 {
                     version: 'v2',
                     default: true,
-                    pages: [{ title: 'Users v2', href: '/api/v2/users' }],
+                    pages: [{ title: 'v2', href: '/api/v2/users' }],
                 },
                 {
                     version: 'v1',
@@ -864,6 +1160,134 @@ describe('active-tab menu scoping', () => {
             ],
         });
     });
+    it('filters identically for every path in a product menu with versions and dropdowns', () => {
+        assertChromeInvariantForEveryPath(productMenuNav);
+        assertChromeInvariantForEveryPath(productMenuNav, false, new Set(['staff']));
+        assertChromeInvariantForEveryPath(productMenuNav, true);
+    });
+    it('resolves off-path menu hrefs identically for every session version and dropdown', () => {
+        const documentation = tabByName(productMenuNav, 'Documentation');
+        if (!('menu' in documentation))
+            throw new Error('Documentation tab has no menu');
+        const itemPaths = new Map(documentation.menu.map((item) => [
+            item.item,
+            getAllPathsInDecoratedNav(item),
+        ]));
+        const versions = [undefined, 'v3', 'v2', 'Legacy'];
+        const dropdownCaches = [
+            new Map(),
+            new Map([['Documentation:Audio:OverviewAPI', 'audio/api/_autosummary/Clip.b']]),
+        ];
+        const gatedPaths = ['internal/runbook', 'studio/v3/api/internal'];
+        const paths = getAllPathsInDecoratedNav(productMenuNav).filter((path) => !gatedPaths.includes(path.replace(/^\//, '')));
+        for (const path of paths) {
+            const currentPath = `/${path.replace(/^\//, '')}`;
+            const { scopedNav } = getScopedNavForPath({
+                decoratedNav: productMenuNav,
+                currentPath,
+            });
+            const isOffPath = (name) => { var _a; return !((_a = itemPaths.get(name)) === null || _a === void 0 ? void 0 : _a.includes(path)); };
+            for (const version of versions) {
+                for (const dropdownCache of dropdownCaches) {
+                    const menuHrefs = (nav) => filterDivisions({
+                        currentPath,
+                        decoratedNav: nav,
+                        userGroups: new Set(),
+                        currentVersion: version,
+                        currentLanguage: undefined,
+                        shouldUseDivisionMatch: true,
+                        cache: { dropdownCache: new Map(dropdownCache) },
+                    }).tabs.map((tab) => { var _a; return (_a = tab.menu) === null || _a === void 0 ? void 0 : _a.filter((item) => isOffPath(item.name)).map((item) => [item.name, item.href]); });
+                    expect(menuHrefs(scopedNav), `${currentPath} ${version}`).toEqual(menuHrefs(productMenuNav));
+                }
+            }
+        }
+    });
+    describe('pages cross-listed in several siblings', () => {
+        it('filters identically for every session version across versioned menu items', () => {
+            assertChromeInvariantForEverySession(crossListedMenuNav, 'version');
+        });
+        it('filters identically for every session language across menu items', () => {
+            assertChromeInvariantForEverySession(crossListedLanguageMenuNav, 'language');
+        });
+        it('filters identically across plain menu items and across tabs', () => {
+            assertChromeInvariantForEverySession(crossListedPlainMenuNav, 'version');
+            assertChromeInvariantForEverySession(crossListedTabsNav, 'version');
+        });
+        it('filters identically when a containing menu item is hidden, for every viewer', () => {
+            assertChromeInvariantForEverySession(crossListedHiddenMenuNav, 'version');
+            assertChromeInvariantForEverySession(crossListedHiddenMenuNav, 'version', true);
+        });
+        it('keeps every menu item containing the page and skeletons the rest', () => {
+            const { scopedNav } = getScopedNavForPath({
+                decoratedNav: crossListedMenuNav,
+                currentPath: '/shared',
+            });
+            const menu = tabByName(scopedNav, 'Docs');
+            if (!('menu' in menu))
+                throw new Error('Docs tab has no menu');
+            const hrefs = (name) => getAllPathsInDecoratedNav(menu.menu.find((item) => item.item === name));
+            expect(hrefs('Studio')).toContain('shared');
+            expect(hrefs('Engine')).toEqual(expect.arrayContaining(['engine/v3/a', 'shared', 'engine/v3/c']));
+            expect(hrefs('Solver')).toEqual(['solver/v3/a', 'solver/v2/a']);
+        });
+    });
+    it('keeps openapi, asyncapi, and global on skeleton-stubbed menu items', () => {
+        const global = { anchors: [{ anchor: 'Status', href: 'https://status.example.com' }] };
+        const docsConfig = {
+            $schema: 'https://mintlify.com/docs.json',
+            name: 'Docs',
+            theme: 'mint',
+            colors: { primary: '#000000' },
+            navigation: {
+                tabs: [
+                    {
+                        tab: 'Docs',
+                        menu: [
+                            { item: 'Home', pages: ['home'] },
+                            {
+                                item: 'API',
+                                openapi: 'api/openapi.json',
+                                asyncapi: 'api/asyncapi.yaml',
+                                global,
+                                versions: [
+                                    { version: 'v2', pages: ['api/v2/users'] },
+                                    { version: 'v1', pages: ['api/v1/users'] },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        };
+        const { navigation } = scopeDocsConfigNavToPath(docsConfig, '/home');
+        if (!('tabs' in navigation))
+            throw new Error('nav has no tabs');
+        const docs = navigation.tabs.find((tab) => tab.tab === 'Docs');
+        if (!docs || !('menu' in docs))
+            throw new Error('Docs tab has no menu');
+        expect(docs.menu.find((item) => item.item === 'API')).toEqual({
+            item: 'API',
+            openapi: 'api/openapi.json',
+            asyncapi: 'api/asyncapi.yaml',
+            global,
+            versions: [
+                { version: 'v2', pages: ['api/v2/users'] },
+                { version: 'v1', pages: ['api/v1/users'] },
+            ],
+        });
+    });
+    it('keeps no off-path api pages in a product menu', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: productMenuNav,
+            currentPath: '/home',
+        });
+        const paths = getAllPathsInDecoratedNav(scopedNav);
+        expect(paths.filter((path) => path.includes('_autosummary'))).toEqual([
+            'engine/v3/py/_autosummary/Engine.a',
+            'studio/v3/api/_autosummary/Model.a',
+        ]);
+    });
     it('carries hidden and groups onto off-path menu item stubs', () => {
         const { scopedNav } = getScopedNavForPath({
             decoratedNav: hiddenMenuTabNav,

package/dist/navigation/scopePrecomputedTargets.test.d.ts

@@ -0,0 +1 @@
+export {};