@mintlify/common 1.0.1023 → 1.0.1024

package/dist/navigation/scopeOffPathDivisions.test.js

@@ -0,0 +1,852 @@
+import { filterDivisions } from './filterDivisions.js';
+import { getAllPathsInDecoratedNav } from './getAllPathsInDecoratedNav.js';
+import { getScopedNavForPath } from './scopeNavToPath.js';
+const multiTabNav = {
+    tabs: [
+        {
+            tab: 'Documentation',
+            groups: [
+                {
+                    group: 'Getting started',
+                    pages: [
+                        { title: 'Quickstart', href: '/quickstart' },
+                        { title: 'Installation', href: '/installation' },
+                    ],
+                },
+            ],
+        },
+        {
+            tab: 'Guides',
+            groups: [
+                {
+                    group: 'Guides',
+                    pages: [
+                        { title: 'Auth', href: '/guides/auth' },
+                        { title: 'Deploy', href: '/guides/deploy' },
+                    ],
+                },
+            ],
+        },
+        {
+            tab: 'Changelog',
+            pages: [{ title: 'Changelog', href: '/changelog' }],
+        },
+        {
+            tab: 'Community',
+            href: 'https://community.example.com',
+        },
+    ],
+};
+const menuTabNav = {
+    tabs: [
+        {
+            tab: 'Database',
+            menu: [
+                {
+                    item: 'Get started',
+                    description: 'Start here',
+                    pages: [
+                        { title: 'Intro', href: '/db/intro' },
+                        { title: 'Install', href: '/db/install' },
+                    ],
+                },
+                {
+                    item: 'Reference',
+                    groups: [
+                        {
+                            group: 'SQL',
+                            pages: [
+                                { title: 'SELECT', href: '/db/sql/select' },
+                                { title: 'INSERT', href: '/db/sql/insert' },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            tab: 'Cloud',
+            menu: [
+                {
+                    item: 'Overview',
+                    pages: [
+                        { title: 'Cloud intro', href: '/cloud/intro' },
+                        { title: 'Pricing', href: '/cloud/pricing' },
+                    ],
+                },
+                {
+                    item: 'Status page',
+                    href: 'https://status.example.com',
+                },
+            ],
+        },
+    ],
+};
+const hiddenAndGatedTabNav = {
+    tabs: [
+        {
+            tab: 'Public',
+            pages: [
+                { title: 'Home', href: '/home' },
+                { title: 'About', href: '/about' },
+            ],
+        },
+        {
+            tab: 'Drafts',
+            pages: [
+                { title: 'Draft one', href: '/drafts/one', hidden: true },
+                { title: 'Draft two', href: '/drafts/two', hidden: true },
+            ],
+        },
+        {
+            tab: 'Internal',
+            pages: [
+                { title: 'Internal one', href: '/internal/one', groups: ['staff'] },
+                { title: 'Internal two', href: '/internal/two', groups: ['staff'] },
+            ],
+        },
+    ],
+};
+const hiddenGroupTabNav = {
+    tabs: [
+        {
+            tab: 'Public',
+            pages: [{ title: 'Home', href: '/home' }],
+        },
+        {
+            tab: 'Archive',
+            groups: [
+                {
+                    group: 'Old docs',
+                    hidden: true,
+                    pages: [
+                        { title: 'Legacy one', href: '/archive/one' },
+                        { title: 'Legacy two', href: '/archive/two' },
+                    ],
+                },
+            ],
+        },
+    ],
+};
+// dropdowns are stateful client-side (dropdownCache), so the dropdown entries
+// themselves stay whole while versions/languages nested inside them still stub
+const dropdownNav = {
+    dropdowns: [
+        {
+            dropdown: 'Platform',
+            versions: [
+                {
+                    version: 'v2',
+                    default: true,
+                    pages: [
+                        { title: 'Platform home', href: '/platform/v2/home' },
+                        { title: 'Platform setup', href: '/platform/v2/setup' },
+                    ],
+                },
+                {
+                    version: 'v1',
+                    pages: [{ title: 'Platform home', href: '/platform/v1/home' }],
+                },
+            ],
+        },
+        {
+            dropdown: 'SDKs',
+            groups: [
+                {
+                    group: 'Libraries',
+                    pages: [
+                        { title: 'Node SDK', href: '/sdks/node' },
+                        { title: 'Python SDK', href: '/sdks/python' },
+                    ],
+                },
+            ],
+        },
+        {
+            dropdown: 'Support',
+            href: 'https://support.example.com',
+        },
+    ],
+};
+// groups: [] denies every viewer (checkNavAccess), unlike an absent groups key
+const denyAllGroupsTabNav = {
+    tabs: [
+        {
+            tab: 'Public',
+            pages: [{ title: 'Home', href: '/home' }],
+        },
+        {
+            tab: 'Locked',
+            pages: [
+                { title: 'Locked one', href: '/locked/one', groups: [] },
+                { title: 'Locked two', href: '/locked/two', groups: [] },
+            ],
+        },
+        {
+            tab: 'Mixed',
+            pages: [
+                { title: 'Deny all', href: '/mixed/deny', groups: [] },
+                { title: 'Staff only', href: '/mixed/staff', groups: ['staff'] },
+            ],
+        },
+    ],
+};
+const anchorNav = {
+    anchors: [
+        {
+            anchor: 'Docs',
+            groups: [
+                {
+                    group: 'Docs',
+                    pages: [
+                        { title: 'Overview', href: '/docs/overview' },
+                        { title: 'Concepts', href: '/docs/concepts' },
+                    ],
+                },
+            ],
+        },
+        {
+            anchor: 'API',
+            pages: [
+                { title: 'Auth API', href: '/api/auth' },
+                { title: 'Users API', href: '/api/users' },
+            ],
+        },
+        {
+            anchor: 'Blog',
+            href: 'https://blog.example.com',
+        },
+    ],
+};
+const versionedTabNav = {
+    tabs: [
+        {
+            tab: 'Docs',
+            pages: [{ title: 'Docs home', href: '/docs' }],
+        },
+        {
+            tab: 'API',
+            versions: [
+                {
+                    version: 'v2',
+                    default: true,
+                    pages: [{ title: 'API v2', href: '/api/v2' }],
+                },
+                {
+                    version: 'v1',
+                    pages: [{ title: 'API v1', href: '/api/v1' }],
+                },
+            ],
+        },
+    ],
+};
+// a sibling version whose pages are all hidden or gated: invisible in the
+// version switcher for anon viewers, so its stub must stay invisible too even
+// when a precomputed jump-map target exists for it
+const hiddenVersionNav = {
+    versions: [
+        {
+            version: 'v2',
+            default: true,
+            pages: [
+                { title: 'Home', href: '/v2/home' },
+                { title: 'Guide', href: '/v2/guide' },
+            ],
+        },
+        {
+            version: 'v1',
+            pages: [
+                { title: 'One', href: '/v1/one', hidden: true },
+                { title: 'Two', href: '/v1/two', hidden: true },
+            ],
+        },
+        {
+            version: 'beta',
+            pages: [
+                { title: 'Alpha', href: '/beta/alpha', groups: ['staff'] },
+                { title: 'Omega', href: '/beta/omega', groups: ['staff'] },
+            ],
+        },
+    ],
+};
+const languagesWithTabsNav = {
+    languages: [
+        {
+            language: 'en',
+            tabs: [
+                {
+                    tab: 'Documentation',
+                    pages: [
+                        { title: 'Quickstart', href: '/en/quickstart' },
+                        { title: 'Installation', href: '/en/installation' },
+                    ],
+                },
+                {
+                    tab: 'Guides',
+                    pages: [{ title: 'Auth guide', href: '/en/guides/auth' }],
+                },
+            ],
+        },
+        {
+            language: 'es',
+            tabs: [
+                {
+                    tab: 'Documentation',
+                    pages: [
+                        { title: 'Quickstart', href: '/es/quickstart' },
+                        { title: 'Installation', href: '/es/installation' },
+                    ],
+                },
+                {
+                    tab: 'Guides',
+                    pages: [{ title: 'Auth guide', href: '/es/guides/auth' }],
+                },
+            ],
+        },
+    ],
+};
+const deepMenuTabNav = {
+    tabs: [
+        {
+            tab: 'Database',
+            menu: [
+                {
+                    item: 'Get started',
+                    description: 'Start here',
+                    pages: [
+                        { title: 'Intro', href: '/db/intro' },
+                        { title: 'Install', href: '/db/install' },
+                    ],
+                },
+                {
+                    item: 'Reference',
+                    description: 'Look things up',
+                    groups: [
+                        {
+                            group: 'SQL',
+                            pages: [
+                                { title: 'SELECT', href: '/ref/sql/select' },
+                                {
+                                    group: 'Functions',
+                                    pages: [
+                                        { title: 'String', href: '/ref/functions/string' },
+                                        { title: 'Array', href: '/ref/functions/array' },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            group: 'System tables',
+                            pages: [
+                                { title: 'Parts', href: '/ref/system/parts' },
+                                { title: 'Query log', href: '/ref/system/query-log' },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    item: 'Concepts',
+                    pages: [
+                        { title: 'OLAP', href: '/concepts/olap' },
+                        { title: 'Columnar', href: '/concepts/columnar' },
+                    ],
+                },
+            ],
+        },
+        {
+            tab: 'Cloud',
+            pages: [{ title: 'Cloud intro', href: '/cloud/intro' }],
+        },
+    ],
+};
+const menuWithVersionsTabNav = {
+    tabs: [
+        {
+            tab: 'API',
+            menu: [
+                {
+                    item: 'Endpoints',
+                    versions: [
+                        {
+                            version: 'v2',
+                            default: true,
+                            pages: [{ title: 'Users v2', href: '/api/v2/users' }],
+                        },
+                        {
+                            version: 'v1',
+                            pages: [{ title: 'Users v1', href: '/api/v1/users' }],
+                        },
+                    ],
+                },
+                {
+                    item: 'Webhooks',
+                    pages: [
+                        { title: 'Events', href: '/api/webhooks/events' },
+                        { title: 'Retries', href: '/api/webhooks/retries' },
+                    ],
+                },
+            ],
+        },
+        {
+            tab: 'Docs',
+            pages: [{ title: 'Docs home', href: '/docs' }],
+        },
+    ],
+};
+const hiddenMenuTabNav = {
+    tabs: [
+        {
+            tab: 'Product',
+            menu: [
+                {
+                    item: 'Public',
+                    pages: [
+                        { title: 'Home', href: '/p/home' },
+                        { title: 'Features', href: '/p/features' },
+                    ],
+                },
+                {
+                    item: 'Drafts',
+                    hidden: true,
+                    pages: [{ title: 'Draft', href: '/p/drafts/one' }],
+                },
+                {
+                    item: 'Internal',
+                    pages: [
+                        {
+                            title: 'Runbook',
+                            href: '/p/internal/runbook',
+                            groups: ['staff'],
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            tab: 'Blog',
+            pages: [{ title: 'Posts', href: '/blog' }],
+        },
+    ],
+};
+function filterWith(decoratedNav, currentPath, currentVersion, currentLanguage, isPreview = false, userGroups = new Set()) {
+    return filterDivisions({
+        currentPath,
+        decoratedNav,
+        userGroups,
+        currentVersion,
+        currentLanguage,
+        shouldUseDivisionMatch: true,
+        cache: { dropdownCache: new Map() },
+        isPreview,
+    });
+}
+function chromeSummary(result) {
+    return {
+        tabs: result.tabs.map(({ name, href, isActive, menu }) => ({
+            name,
+            href,
+            isActive,
+            menu: menu === null || menu === void 0 ? void 0 : menu.map((item) => ({ name: item.name, href: item.href })),
+        })),
+        anchors: result.anchors.map(({ name, href, isActive }) => ({ name, href, isActive })),
+        versions: result.versions.map(({ name, href, isActive }) => ({ name, href, isActive })),
+        languages: result.languages.map(({ name, isActive }) => ({ name, isActive })),
+        dropdowns: result.dropdowns.map(({ name, href, isActive }) => ({ name, href, isActive })),
+    };
+}
+function mapHrefs(map) {
+    return new Map([...map.entries()].map(([key, value]) => [key, value.href]));
+}
+function assertChromeInvariantForEveryPath(nav, isPreview = false, userGroups = new Set()) {
+    const paths = getAllPathsInDecoratedNav(nav);
+    expect(paths.length).toBeGreaterThan(0);
+    for (const path of paths) {
+        const currentPath = `/${path.replace(/^\//, '')}`;
+        const scoped = getScopedNavForPath({ decoratedNav: nav, currentPath, userGroups, isPreview });
+        const full = filterWith(nav, currentPath, scoped.currentVersion, scoped.currentLanguage, isPreview, userGroups);
+        const rescoped = filterWith(scoped.scopedNav, currentPath, scoped.currentVersion, scoped.currentLanguage, isPreview, userGroups);
+        expect(rescoped.groupsOrPages, currentPath).toEqual(full.groupsOrPages);
+        expect(chromeSummary(rescoped), currentPath).toEqual(chromeSummary(full));
+        expect(mapHrefs(rescoped.firstHrefInVersion), currentPath).toEqual(mapHrefs(full.firstHrefInVersion));
+        expect(mapHrefs(rescoped.firstHrefInLanguage), currentPath).toEqual(mapHrefs(full.firstHrefInLanguage));
+    }
+}
+function tabByName(nav, name) {
+    if (!('tabs' in nav))
+        throw new Error('nav has no tabs');
+    const tab = nav.tabs.find((entry) => entry.tab === name);
+    if (!tab)
+        throw new Error(`tab ${name} not found`);
+    return tab;
+}
+describe('off-path tab and anchor stubbing', () => {
+    it('filters identically to the full nav for every path in a multi-tab nav', () => {
+        assertChromeInvariantForEveryPath(multiTabNav);
+    });
+    // home URLs reach the scoper as '/' or 'index' without matching any nav
+    // href; filterDivisions resolves them to the first page internally, so the
+    // scoper must still produce an equivalently-filtering tree
+    it('filters identically for home paths that match no nav href', () => {
+        for (const nav of [multiTabNav, menuTabNav, anchorNav, versionedTabNav]) {
+            for (const currentPath of ['/', '/index', '']) {
+                const scoped = getScopedNavForPath({ decoratedNav: nav, currentPath });
+                const full = filterWith(nav, currentPath, scoped.currentVersion, scoped.currentLanguage);
+                const rescoped = filterWith(scoped.scopedNav, currentPath, scoped.currentVersion, scoped.currentLanguage);
+                expect(rescoped.groupsOrPages, `${currentPath}`).toEqual(full.groupsOrPages);
+                expect(chromeSummary(rescoped), `${currentPath}`).toEqual(chromeSummary(full));
+            }
+        }
+    });
+    it('filters identically to the full nav for every path in a menu-tab nav', () => {
+        assertChromeInvariantForEveryPath(menuTabNav);
+    });
+    it('filters identically to the full nav for every path in an anchor nav', () => {
+        assertChromeInvariantForEveryPath(anchorNav);
+    });
+    it('filters identically to the full nav for every path in a languages-with-tabs nav', () => {
+        assertChromeInvariantForEveryPath(languagesWithTabsNav);
+    });
+    it('collapses off-path tabs to a single resolved page', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: multiTabNav,
+            currentPath: '/quickstart',
+        });
+        const guides = tabByName(scopedNav, 'Guides');
+        expect(guides).toEqual({
+            tab: 'Guides',
+            pages: [{ title: 'Guides', href: '/guides/auth' }],
+        });
+        const documentation = tabByName(scopedNav, 'Documentation');
+        expect(documentation).toEqual(tabByName(multiTabNav, 'Documentation'));
+        const community = tabByName(scopedNav, 'Community');
+        expect(community).toEqual({ tab: 'Community', href: 'https://community.example.com' });
+    });
+    it('keeps menus on stubbed tabs with each item collapsed to its first page', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: menuTabNav,
+            currentPath: '/db/intro',
+        });
+        const cloud = tabByName(scopedNav, 'Cloud');
+        expect(cloud).toEqual({
+            tab: 'Cloud',
+            menu: [
+                {
+                    item: 'Overview',
+                    pages: [{ title: 'Overview', href: '/cloud/intro' }],
+                },
+                {
+                    item: 'Status page',
+                    href: 'https://status.example.com',
+                },
+            ],
+            pages: [{ title: 'Cloud', href: '/cloud/intro' }],
+        });
+        expect(tabByName(scopedNav, 'Database')).toEqual({
+            tab: 'Database',
+            menu: [
+                {
+                    item: 'Get started',
+                    description: 'Start here',
+                    pages: [
+                        { title: 'Intro', href: '/db/intro' },
+                        { title: 'Install', href: '/db/install' },
+                    ],
+                },
+                {
+                    item: 'Reference',
+                    pages: [{ title: 'Reference', href: '/db/sql/select' }],
+                },
+            ],
+        });
+    });
+    it('keeps hidden-only and gated-only tabs invisible to anonymous filtering', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: hiddenAndGatedTabNav,
+            currentPath: '/home',
+        });
+        expect(tabByName(scopedNav, 'Drafts')).toEqual({
+            tab: 'Drafts',
+            pages: [{ title: 'Drafts', href: '/drafts/one', hidden: true }],
+        });
+        expect(tabByName(scopedNav, 'Internal')).toEqual({
+            tab: 'Internal',
+            pages: [{ title: 'Internal', href: '/internal/one', groups: ['staff'] }],
+        });
+        const full = filterWith(hiddenAndGatedTabNav, '/home', undefined, undefined);
+        const rescoped = filterWith(scopedNav, '/home', undefined, undefined);
+        expect(rescoped.tabs.map(({ name }) => name)).toEqual(full.tabs.map(({ name }) => name));
+        expect(full.tabs.map(({ name }) => name)).toEqual(['Public']);
+    });
+    it('filters identically for every path in navs with hidden or gated divisions', () => {
+        assertChromeInvariantForEveryPath(hiddenAndGatedTabNav);
+        assertChromeInvariantForEveryPath(hiddenGroupTabNav);
+    });
+    it('filters identically for a group user, with gated stub targets carrying their groups', () => {
+        const staff = new Set(['staff']);
+        assertChromeInvariantForEveryPath(hiddenAndGatedTabNav, false, staff);
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: hiddenAndGatedTabNav,
+            currentPath: '/home',
+            userGroups: staff,
+        });
+        expect(tabByName(scopedNav, 'Internal')).toEqual({
+            tab: 'Internal',
+            pages: [{ title: 'Internal', href: '/internal/one', groups: ['staff'] }],
+        });
+        const full = filterWith(hiddenAndGatedTabNav, '/home', undefined, undefined, false, staff);
+        const rescoped = filterWith(scopedNav, '/home', undefined, undefined, false, staff);
+        expect(rescoped.tabs.map(({ name }) => name)).toEqual(full.tabs.map(({ name }) => name));
+        expect(full.tabs.map(({ name }) => name)).toEqual(['Public', 'Internal']);
+    });
+    it('keeps a tab whose pages sit under a hidden group invisible to anonymous filtering', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: hiddenGroupTabNav,
+            currentPath: '/home',
+        });
+        expect(tabByName(scopedNav, 'Archive')).toEqual({
+            tab: 'Archive',
+            pages: [{ title: 'Archive', href: '/archive/one', hidden: true }],
+        });
+        const full = filterWith(hiddenGroupTabNav, '/home', undefined, undefined);
+        const rescoped = filterWith(scopedNav, '/home', undefined, undefined);
+        expect(full.tabs.map(({ name }) => name)).toEqual(['Public']);
+        expect(rescoped.tabs.map(({ name }) => name)).toEqual(full.tabs.map(({ name }) => name));
+    });
+    it('filters identically under preview mode, where hidden and gated content is visible', () => {
+        assertChromeInvariantForEveryPath(hiddenAndGatedTabNav, true);
+        assertChromeInvariantForEveryPath(hiddenGroupTabNav, true);
+        assertChromeInvariantForEveryPath(menuTabNav, true);
+    });
+    it('filters identically for every path in a dropdown nav, stubbing versions inside dropdowns', () => {
+        assertChromeInvariantForEveryPath(dropdownNav);
+        assertChromeInvariantForEveryPath(dropdownNav, true);
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: dropdownNav,
+            currentPath: '/platform/v2/setup',
+        });
+        if (!('dropdowns' in scopedNav) || !('dropdowns' in dropdownNav))
+            throw new Error('nav has no dropdowns');
+        const platform = scopedNav.dropdowns[0];
+        const fullPlatform = dropdownNav.dropdowns[0];
+        if (!platform || !('versions' in platform))
+            throw new Error('platform dropdown has no versions');
+        if (!fullPlatform || !('versions' in fullPlatform))
+            throw new Error('full platform dropdown has no versions');
+        expect(platform.versions[0]).toEqual(fullPlatform.versions[0]);
+        expect(platform.versions[1]).toEqual({
+            version: 'v1',
+            pages: [{ title: 'v1', href: '/platform/v1/home' }],
+        });
+        expect(scopedNav.dropdowns[1]).toEqual(dropdownNav.dropdowns[1]);
+        expect(scopedNav.dropdowns[2]).toEqual(dropdownNav.dropdowns[2]);
+    });
+    it('keeps hidden/gated sibling versions invisible even with precomputed jump targets', () => {
+        assertChromeInvariantForEveryPath(hiddenVersionNav);
+        assertChromeInvariantForEveryPath(hiddenVersionNav, false, new Set(['staff']));
+        assertChromeInvariantForEveryPath(hiddenVersionNav, true);
+    });
+    it('keeps deny-all groups: [] divisions invisible, carrying groups onto stubs', () => {
+        assertChromeInvariantForEveryPath(denyAllGroupsTabNav);
+        assertChromeInvariantForEveryPath(denyAllGroupsTabNav, false, new Set(['staff']));
+        assertChromeInvariantForEveryPath(denyAllGroupsTabNav, true);
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: denyAllGroupsTabNav,
+            currentPath: '/home',
+        });
+        expect(tabByName(scopedNav, 'Locked')).toEqual({
+            tab: 'Locked',
+            pages: [{ title: 'Locked', href: '/locked/one', groups: [] }],
+        });
+        // deny-all candidates must not win the "anonymously visible" pool over
+        // gated ones the viewer could actually hold
+        expect(tabByName(scopedNav, 'Mixed')).toEqual({
+            tab: 'Mixed',
+            pages: [{ title: 'Mixed', href: '/mixed/deny', groups: [] }],
+        });
+        const full = filterWith(denyAllGroupsTabNav, '/home', undefined, undefined);
+        const rescoped = filterWith(scopedNav, '/home', undefined, undefined);
+        expect(full.tabs.map(({ name }) => name)).toEqual(['Public']);
+        expect(rescoped.tabs.map(({ name }) => name)).toEqual(full.tabs.map(({ name }) => name));
+    });
+    it('collapses off-path anchors and keeps external ones untouched', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: anchorNav,
+            currentPath: '/docs/overview',
+        });
+        if (!('anchors' in scopedNav))
+            throw new Error('nav has no anchors');
+        expect(scopedNav.anchors).toEqual([
+            ...('anchors' in anchorNav ? [anchorNav.anchors[0]] : []),
+            { anchor: 'API', pages: [{ title: 'API', href: '/api/auth' }] },
+            { anchor: 'Blog', href: 'https://blog.example.com' },
+        ]);
+    });
+    it('never stubs a tab with nested versions at the tab level', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: versionedTabNav,
+            currentPath: '/docs',
+        });
+        expect(tabByName(scopedNav, 'API')).toEqual({
+            tab: 'API',
+            versions: [
+                {
+                    version: 'v2',
+                    default: true,
+                    pages: [{ title: 'API v2', href: '/api/v2' }],
+                },
+                {
+                    version: 'v1',
+                    pages: [{ title: 'v1', href: '/api/v1' }],
+                },
+            ],
+        });
+    });
+    it('stubs nothing when no tab contains the current path', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: multiTabNav,
+            currentPath: '/not-in-any-tab',
+        });
+        expect(scopedNav).toEqual(multiTabNav);
+    });
+    it('filters identically to the full nav for every path in a versioned-tab nav', () => {
+        assertChromeInvariantForEveryPath(versionedTabNav);
+    });
+    it('stubs off-path tabs inside the active language and re-derives stably', () => {
+        const scoped = getScopedNavForPath({
+            decoratedNav: languagesWithTabsNav,
+            currentPath: '/en/quickstart',
+        });
+        if (!('languages' in scoped.scopedNav))
+            throw new Error('nav has no languages');
+        const en = scoped.scopedNav.languages.find((language) => language.language === 'en');
+        if (!en || !('tabs' in en))
+            throw new Error('en language has no tabs');
+        expect(en.tabs.find((tab) => tab.tab === 'Guides')).toEqual({
+            tab: 'Guides',
+            pages: [{ title: 'Guides', href: '/en/guides/auth' }],
+        });
+        const rescoped = getScopedNavForPath({
+            decoratedNav: scoped.scopedNav,
+            currentPath: '/en/quickstart',
+        });
+        expect(rescoped.scopedNav).toEqual(scoped.scopedNav);
+    });
+});
+describe('active-tab menu scoping', () => {
+    it('filters identically to the full nav for every path in a deep menu nav', () => {
+        assertChromeInvariantForEveryPath(deepMenuTabNav);
+    });
+    it('filters identically to the full nav for every path with versions inside a menu', () => {
+        assertChromeInvariantForEveryPath(menuWithVersionsTabNav);
+    });
+    it('filters identically with hidden and gated menu items for every viewer', () => {
+        assertChromeInvariantForEveryPath(hiddenMenuTabNav);
+        assertChromeInvariantForEveryPath(hiddenMenuTabNav, false, new Set(['staff']));
+        assertChromeInvariantForEveryPath(hiddenMenuTabNav, true);
+    });
+    it('stubs off-path menu items within the active tab, keeping their metadata', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: deepMenuTabNav,
+            currentPath: '/db/intro',
+        });
+        const database = tabByName(scopedNav, 'Database');
+        if (!('menu' in database))
+            throw new Error('Database tab has no menu');
+        expect(database.menu).toEqual([
+            {
+                item: 'Get started',
+                description: 'Start here',
+                pages: [
+                    { title: 'Intro', href: '/db/intro' },
+                    { title: 'Install', href: '/db/install' },
+                ],
+            },
+            {
+                item: 'Reference',
+                description: 'Look things up',
+                pages: [{ title: 'Reference', href: '/ref/sql/select' }],
+            },
+            {
+                item: 'Concepts',
+                pages: [{ title: 'Concepts', href: '/concepts/olap' }],
+            },
+        ]);
+    });
+    it('expands the menu item containing a deep path and collapses its siblings', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: deepMenuTabNav,
+            currentPath: '/ref/functions/string',
+        });
+        const database = tabByName(scopedNav, 'Database');
+        if (!('menu' in database))
+            throw new Error('Database tab has no menu');
+        const reference = database.menu.find((item) => item.item === 'Reference');
+        const original = tabByName(deepMenuTabNav, 'Database');
+        if (!('menu' in original))
+            throw new Error('Database tab has no menu');
+        expect(reference).toEqual(original.menu.find((item) => item.item === 'Reference'));
+        expect(database.menu.find((item) => item.item === 'Get started')).toEqual({
+            item: 'Get started',
+            description: 'Start here',
+            pages: [{ title: 'Get started', href: '/db/intro' }],
+        });
+    });
+    it('keeps menu items containing versions whole and version-stubs inside them', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: menuWithVersionsTabNav,
+            currentPath: '/api/webhooks/events',
+        });
+        const api = tabByName(scopedNav, 'API');
+        if (!('menu' in api))
+            throw new Error('API tab has no menu');
+        expect(api.menu.find((item) => item.item === 'Webhooks')).toEqual({
+            item: 'Webhooks',
+            pages: [
+                { title: 'Events', href: '/api/webhooks/events' },
+                { title: 'Retries', href: '/api/webhooks/retries' },
+            ],
+        });
+        expect(api.menu.find((item) => item.item === 'Endpoints')).toEqual({
+            item: 'Endpoints',
+            versions: [
+                {
+                    version: 'v2',
+                    default: true,
+                    pages: [{ title: 'Users v2', href: '/api/v2/users' }],
+                },
+                {
+                    version: 'v1',
+                    pages: [{ title: 'v1', href: '/api/v1/users' }],
+                },
+            ],
+        });
+    });
+    it('carries hidden and groups onto off-path menu item stubs', () => {
+        const { scopedNav } = getScopedNavForPath({
+            decoratedNav: hiddenMenuTabNav,
+            currentPath: '/p/home',
+        });
+        const product = tabByName(scopedNav, 'Product');
+        if (!('menu' in product))
+            throw new Error('Product tab has no menu');
+        expect(product.menu.find((item) => item.item === 'Drafts')).toEqual({
+            item: 'Drafts',
+            hidden: true,
+            pages: [{ title: 'Drafts', href: '/p/drafts/one' }],
+        });
+        expect(product.menu.find((item) => item.item === 'Internal')).toEqual({
+            item: 'Internal',
+            pages: [{ title: 'Internal', href: '/p/internal/runbook', groups: ['staff'] }],
+        });
+    });
+    it('re-derives stably from an already scoped menu nav', () => {
+        const scoped = getScopedNavForPath({
+            decoratedNav: deepMenuTabNav,
+            currentPath: '/db/intro',
+        });
+        const rescoped = getScopedNavForPath({
+            decoratedNav: scoped.scopedNav,
+            currentPath: '/db/intro',
+        });
+        expect(rescoped.scopedNav).toEqual(scoped.scopedNav);
+    });
+});