@mintlify/common 1.0.1197 → 1.0.1199

package/dist/mdx/lib/remark-utils.js

@@ -1,3 +1,4 @@
+import { isVisibilityElement, resolveVisibilityFor, } from '../plugins/remark/remarkVisibilityForMarkdown.js';
 export const createMdxJsxAttribute = (key, value) => {
     return {
         type: 'mdxJsxAttribute',
@@ -24,6 +25,13 @@ export const getTableOfContentsTitle = (node, index = 1, children = EMPTY_CHILDR
         const labelAttr = node.attributes.find((attr) => 'name' in attr && attr.name === 'label' && typeof attr.value === 'string');
         return (_a = labelAttr === null || labelAttr === void 0 ? void 0 : labelAttr.value) !== null && _a !== void 0 ? _a : '';
     }
+    if (isVisibilityElement(node)) {
+        const resolution = resolveVisibilityFor(node);
+        const visibleToEveryone = resolution.kind === 'dynamic' ||
+            (resolution.kind === 'audience' && resolution.audience === 'humans');
+        if (!visibleToEveryone)
+            return '';
+    }
     const lastChild = children[index - 1];
     const isText = node.type === 'text';
     const isInlineCode = node.type === 'inlineCode';

package/dist/mdx/plugins/remark/remarkExtractTableOfContents.js

@@ -3,7 +3,7 @@ import { safeCleanHeadingId, slugify } from '../../../slugify.js';
 import { createMdxJsxAttribute, getTableOfContentsTitle, getTitleMarkdownText, } from '../../lib/remark-utils.js';
 import { isMdxJsxFragment } from '../../utils.js';
 import { AVOIDED_PAGE_MODES, HEADING_LEVELS } from './remarkComponentIds.js';
-import { isHiddenFromHumans, isVisibilityElement, resolveVisibilityFor, } from './remarkVisibilityForMarkdown.js';
+import { isHiddenFromHumans, isVisibilityElement, resolveVisibilityFor, toVisibilityAuthRule, } from './remarkVisibilityForMarkdown.js';
 import { isVariationElement, resolveVariationIds } from './variation.js';
 export const HEADING_NAMES = ['h1', 'h2', 'h3', 'h4'];
 const COMPONENTS_TO_EXCLUDE_HEADINGS = [
@@ -20,6 +20,13 @@ function getStringAttribute(attributes, name) {
     }
     return undefined;
 }
+const authRuleKey = (rule) => typeof rule === 'string' ? rule : JSON.stringify([...rule.groups].sort());
+const hasAuthRules = (childRules, parentRules) => {
+    if (parentRules === undefined)
+        return true;
+    const childKeys = new Set(childRules === null || childRules === void 0 ? void 0 : childRules.map(authRuleKey));
+    return parentRules.every((rule) => childKeys.has(authRuleKey(rule)));
+};
 export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
     // Unified slug deduplication: both custom IDs and auto-generated slugs
     // share the same seen-slug state so they cannot collide.
@@ -46,6 +53,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
         const tabContentMap = new Map();
         const viewContentMap = new Map();
         const variationContentMap = new Map();
+        const authRulesContentMap = new Map();
         // Maps a Step node to the titleSize inherited from its parent <Steps>.
         // At render time <Steps titleSize> is forwarded to each child <Step> that
         // doesn't set its own titleSize, so the TOC must honor the same fallback.
@@ -61,12 +69,26 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                 });
             }
             const visibilityNode = node;
-            if (isVisibilityElement(visibilityNode) &&
-                isHiddenFromHumans(resolveVisibilityFor(visibilityNode))) {
-                visit(node, (childNode) => {
-                    if (childNode !== node)
-                        excludedNodes.add(childNode);
-                });
+            if (isVisibilityElement(visibilityNode)) {
+                const resolution = resolveVisibilityFor(visibilityNode);
+                const authRule = toVisibilityAuthRule(resolution);
+                if (isHiddenFromHumans(resolution)) {
+                    visit(node, (childNode) => {
+                        if (childNode !== node)
+                            excludedNodes.add(childNode);
+                    });
+                }
+                else if (authRule) {
+                    visit(node, (childNode) => {
+                        var _a;
+                        if (childNode === node)
+                            return;
+                        authRulesContentMap.set(childNode, [
+                            ...((_a = authRulesContentMap.get(childNode)) !== null && _a !== void 0 ? _a : []),
+                            authRule,
+                        ]);
+                    });
+                }
             }
             if (node.type === 'mdxJsxFlowElement' && node.name === 'Steps') {
                 const stepsTitleSize = getStringAttribute(node.attributes, 'titleSize');
@@ -123,6 +145,8 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
             }
         });
         const pushEntry = (entry, level) => {
+            if (!entry.title.trim())
+                return;
             if (level !== undefined && Number(level) <= 2) {
                 hasTopLayer = true;
                 contents.push(entry);
@@ -133,23 +157,26 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
             if (hasTopLayer) {
                 const lastTopLevel = contents.at(-1);
                 if (lastTopLevel &&
+                    !(lastTopLevel.depth > 2 && lastTopLevel.depth >= entry.depth) &&
                     (lastTopLevel.tabId === undefined || lastTopLevel.tabId === entry.tabId) &&
                     (lastTopLevel.viewId === undefined || lastTopLevel.viewId === entry.viewId) &&
                     (lastTopLevel.variationIds === undefined ||
                         (entry.variationIds !== undefined &&
-                            entry.variationIds.every((id) => { var _a; return (_a = lastTopLevel.variationIds) === null || _a === void 0 ? void 0 : _a.includes(id); })))) {
+                            entry.variationIds.every((id) => { var _a; return (_a = lastTopLevel.variationIds) === null || _a === void 0 ? void 0 : _a.includes(id); }))) &&
+                    hasAuthRules(entry.authRules, lastTopLevel.authRules)) {
                     arrToPushInto = lastTopLevel.children;
                 }
             }
             arrToPushInto.push(entry);
         };
         visit(tree, (node) => {
-            var _a, _b, _c, _d, _e, _f, _g;
+            var _a, _b, _c, _d, _e, _f, _g, _h;
             if (excludedNodes.has(node))
                 return;
             const currentTabId = tabContentMap.get(node);
             const currentViewId = viewContentMap.get(node);
             const currentVariationIds = variationContentMap.get(node);
+            const currentAuthRules = authRulesContentMap.get(node);
             if (node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression') {
                 const fragmentHeadings = (_a = node.data) === null || _a === void 0 ? void 0 : _a.tableOfContents;
                 if (!(fragmentHeadings === null || fragmentHeadings === void 0 ? void 0 : fragmentHeadings.length))
@@ -165,18 +192,20 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                 };
                 register(fragmentHeadings);
                 for (const heading of fragmentHeadings) {
-                    pushEntry(Object.assign(Object.assign({}, heading), { tabId: currentTabId, viewId: currentViewId, variationIds: currentVariationIds }), heading.depth);
+                    pushEntry(Object.assign(Object.assign({}, heading), { tabId: currentTabId, viewId: currentViewId, variationIds: currentVariationIds, authRules: currentAuthRules || heading.authRules
+                            ? [...(currentAuthRules !== null && currentAuthRules !== void 0 ? currentAuthRules : []), ...((_b = heading.authRules) !== null && _b !== void 0 ? _b : [])]
+                            : undefined }), heading.depth);
                 }
                 return;
             }
             const isValidHeading = node.type === 'heading' && HEADING_LEVELS.includes(node.depth);
-            const isValidMdxHeading = node.type === 'mdxJsxFlowElement' && HEADING_NAMES.includes((_b = node.name) !== null && _b !== void 0 ? _b : '');
+            const isValidMdxHeading = node.type === 'mdxJsxFlowElement' && HEADING_NAMES.includes((_c = node.name) !== null && _c !== void 0 ? _c : '');
             const isTransformedHeading = node.type === 'mdxJsxFlowElement' && node.name === 'Heading';
             const isValidUpdate = node.type === 'mdxJsxFlowElement' &&
                 node.name === 'Update' &&
                 node.attributes.some((attr) => 'name' in attr && attr.name === 'label');
             const stepTitleSize = node.type === 'mdxJsxFlowElement' && node.name === 'Step'
-                ? ((_c = getStringAttribute(node.attributes, 'titleSize')) !== null && _c !== void 0 ? _c : inheritedStepTitleSizeMap.get(node))
+                ? ((_d = getStringAttribute(node.attributes, 'titleSize')) !== null && _d !== void 0 ? _d : inheritedStepTitleSizeMap.get(node))
                 : undefined;
             const hasNoAnchor = node.type === 'mdxJsxFlowElement' &&
                 node.attributes.some((attr) => 'name' in attr &&
@@ -185,7 +214,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                         attr.value === 'true' ||
                         (typeof attr.value === 'object' && attr.value.value === 'true')));
             const stepTitle = node.type === 'mdxJsxFlowElement' && node.name === 'Step'
-                ? getTitleMarkdownText(node, (_d = getStringAttribute(node.attributes, 'title')) !== null && _d !== void 0 ? _d : '')
+                ? getTitleMarkdownText(node, (_e = getStringAttribute(node.attributes, 'title')) !== null && _e !== void 0 ? _e : '')
                 : undefined;
             const isValidStep = node.type === 'mdxJsxFlowElement' &&
                 node.name === 'Step' &&
@@ -194,7 +223,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                 (stepTitle === null || stepTitle === void 0 ? void 0 : stepTitle.trim()) !== '';
             const hasIdAttribute = node.type === 'mdxJsxFlowElement' &&
                 node.attributes.some((attr) => 'name' in attr && attr.name === 'id');
-            const isAvoidedPageMode = AVOIDED_PAGE_MODES.includes((_e = pageMetadata === null || pageMetadata === void 0 ? void 0 : pageMetadata.mode) !== null && _e !== void 0 ? _e : '');
+            const isAvoidedPageMode = AVOIDED_PAGE_MODES.includes((_f = pageMetadata === null || pageMetadata === void 0 ? void 0 : pageMetadata.mode) !== null && _f !== void 0 ? _f : '');
             if (!isValidHeading &&
                 !isValidMdxHeading &&
                 !isTransformedHeading &&
@@ -212,7 +241,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
             }
             else if ('name' in node && node.name === 'Step') {
                 const titleSizeToLevel = { h2: 2, h3: 3, h4: 4 };
-                level = (_f = titleSizeToLevel[stepTitleSize !== null && stepTitleSize !== void 0 ? stepTitleSize : '']) !== null && _f !== void 0 ? _f : 3;
+                level = (_g = titleSizeToLevel[stepTitleSize !== null && stepTitleSize !== void 0 ? stepTitleSize : '']) !== null && _g !== void 0 ? _g : 3;
                 // @ts-expect-error we're assigning to depth despite the node not containing depth in the type
                 node.depth = level;
             }
@@ -225,7 +254,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                     level = levelAttr.value;
                 }
             }
-            else if ('name' in node && ((_g = node.name) === null || _g === void 0 ? void 0 : _g[1])) {
+            else if ('name' in node && ((_h = node.name) === null || _h === void 0 ? void 0 : _h[1])) {
                 const num = Number(node.name[1]);
                 level = !isNaN(num) ? num : undefined;
                 if (level !== undefined) {
@@ -300,6 +329,7 @@ export const remarkExtractTableOfContents = (mdxExtracts, pageMetadata) => {
                 tabId: currentTabId,
                 viewId: currentViewId,
                 variationIds: currentVariationIds,
+                authRules: currentAuthRules,
             }, level);
         });
         if (mdxExtracts) {

package/dist/mdx/plugins/remark/remarkMdxRemoveUnknownJsx/index.d.ts

@@ -1,4 +1,4 @@
 import type { Root } from 'mdast';
 export declare const remarkMdxRemoveUnknownJsx: ({ allowlist }?: {
     allowlist?: string[];
-}) => (tree: Root) => Root | import("mdast").Link | import("mdast").Delete | import("mdast").Code | import("mdast").Text | import("mdast").Heading | import("mdast-util-mdx").MdxJsxFlowElement | import("mdast-util-mdx").MdxJsxTextElement | import("mdast").Blockquote | import("mdast").Break | import("mdast").Definition | import("mdast").Emphasis | import("mdast").FootnoteDefinition | import("mdast").FootnoteReference | import("mdast").Html | import("mdast").Image | import("mdast").ImageReference | import("mdast").InlineCode | import("mdast").LinkReference | import("mdast").List | import("mdast").ListItem | import("mdast").Paragraph | import("mdast").Strong | import("mdast").Table | import("mdast").TableCell | import("mdast").TableRow | import("mdast").ThematicBreak | import("mdast").Yaml | import("mdast-util-math").InlineMath | import("mdast-util-math").Math | import("mdast-util-mdx-expression").MdxTextExpression | import("mdast-util-mdx-expression").MdxFlowExpression | import("mdast-util-mdxjs-esm").MdxjsEsm;
+}) => (tree: Root) => Root | import("mdast-util-mdx-jsx").MdxJsxFlowElement | import("mdast-util-mdx-jsx").MdxJsxTextElement | import("mdast").Link | import("mdast").Delete | import("mdast").Code | import("mdast").Blockquote | import("mdast").Break | import("mdast").Definition | import("mdast").Emphasis | import("mdast").FootnoteDefinition | import("mdast").FootnoteReference | import("mdast").Heading | import("mdast").Html | import("mdast").Image | import("mdast").ImageReference | import("mdast").InlineCode | import("mdast").LinkReference | import("mdast").List | import("mdast").ListItem | import("mdast").Paragraph | import("mdast").Strong | import("mdast").Table | import("mdast").TableCell | import("mdast").TableRow | import("mdast").Text | import("mdast").ThematicBreak | import("mdast").Yaml | import("mdast-util-math").InlineMath | import("mdast-util-math").Math | import("mdast-util-mdx-expression").MdxTextExpression | import("mdast-util-mdx-expression").MdxFlowExpression | import("mdast-util-mdxjs-esm").MdxjsEsm;

package/dist/mdx/plugins/remark/remarkValidateVisibility.js

@@ -1,15 +1,15 @@
 import { visit } from 'unist-util-visit';
-import { isVisibilityElement, resolveVisibilityFor } from './remarkVisibilityForMarkdown.js';
+import { VISIBILITY_FOR_EXPECTED, isVisibilityElement, resolveVisibilityFor, } from './remarkVisibilityForMarkdown.js';
 export const remarkValidateVisibility = () => (tree) => {
     visit(tree, (node) => {
         if (!isVisibilityElement(node))
             return;
         const resolution = resolveVisibilityFor(node);
         if (resolution.kind === 'invalid') {
-            console.warn(`<Visibility for="${resolution.raw}"> has an unknown audience — expected "humans" or "agents". The content will be hidden from humans.`);
+            console.warn(`<Visibility for="${resolution.raw}"> has an unknown audience — expected ${VISIBILITY_FOR_EXPECTED}. The content will be hidden from humans.`);
         }
         if (resolution.kind === 'missing') {
-            console.warn('<Visibility> is missing its "for" audience — expected "humans" or "agents". The content will be hidden from humans.');
+            console.warn(`<Visibility> is missing its "for" audience — expected ${VISIBILITY_FOR_EXPECTED}. The content will be hidden from humans.`);
         }
     });
 };

package/dist/mdx/plugins/remark/remarkVisibilityForMarkdown.d.ts

@@ -5,9 +5,22 @@ export declare function isVisibilityElement(node: {
     type: string;
     name?: string | null;
 }): node is MdxJsxElement;
+export declare const VISIBILITY_AUDIENCES: readonly ["humans", "agents", "signed-in", "signed-out"];
+export type VisibilityAudience = (typeof VISIBILITY_AUDIENCES)[number];
+export declare const VISIBILITY_FOR_EXPECTED = "\"humans\", \"agents\", \"signed-in\", \"signed-out\", or { groups: [...] }";
+export type VisibilityAuthRule = 'signed-in' | 'signed-out' | {
+    groups: string[];
+};
+export type VisibilityViewer = {
+    signedIn: boolean;
+    groups: readonly string[];
+};
 export type VisibilityResolution = {
     kind: 'audience';
-    audience: 'humans' | 'agents';
+    audience: VisibilityAudience;
+} | {
+    kind: 'groups';
+    groups: string[];
 } | {
     kind: 'invalid';
     raw: string;
@@ -16,6 +29,10 @@ export type VisibilityResolution = {
 } | {
     kind: 'missing';
 };
+export declare function isVisibilityAudience(value: unknown): value is VisibilityAudience;
 export declare function resolveVisibilityFor(node: MdxJsxElement): VisibilityResolution;
 export declare function isHiddenFromHumans(resolution: VisibilityResolution): boolean;
+export declare function isHiddenFromAgents(resolution: VisibilityResolution): boolean;
+export declare function toVisibilityAuthRule(resolution: VisibilityResolution): VisibilityAuthRule | undefined;
+export declare function matchesVisibilityAuthRule(rule: VisibilityAuthRule, viewer: VisibilityViewer): boolean;
 export declare const remarkVisibilityForMarkdown: () => (tree: Root) => void;

package/dist/mdx/plugins/remark/remarkVisibilityForMarkdown.js

@@ -5,17 +5,88 @@ export function isVisibilityElement(node) {
 function isMdxJsxElement(node) {
     return node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement';
 }
+export const VISIBILITY_AUDIENCES = ['humans', 'agents', 'signed-in', 'signed-out'];
+export const VISIBILITY_FOR_EXPECTED = '"humans", "agents", "signed-in", "signed-out", or { groups: [...] }';
+export function isVisibilityAudience(value) {
+    return VISIBILITY_AUDIENCES.some((audience) => audience === value);
+}
+function expressionOf(value) {
+    var _a, _b;
+    const statement = (_b = (_a = value.data) === null || _a === void 0 ? void 0 : _a.estree) === null || _b === void 0 ? void 0 : _b.body[0];
+    return (statement === null || statement === void 0 ? void 0 : statement.type) === 'ExpressionStatement' ? statement.expression : undefined;
+}
+function foldString(node) {
+    var _a, _b, _c;
+    switch (node === null || node === void 0 ? void 0 : node.type) {
+        case 'Literal':
+            return typeof node.value === 'string' ? node.value : undefined;
+        case 'TemplateLiteral': {
+            let out = (_b = (_a = node.quasis[0]) === null || _a === void 0 ? void 0 : _a.value.cooked) !== null && _b !== void 0 ? _b : undefined;
+            for (const [index, expression] of node.expressions.entries()) {
+                const folded = foldString(expression);
+                const next = (_c = node.quasis[index + 1]) === null || _c === void 0 ? void 0 : _c.value.cooked;
+                if (out === undefined || folded === undefined || next == null)
+                    return undefined;
+                out += folded + next;
+            }
+            return out;
+        }
+        case 'BinaryExpression': {
+            if (node.operator !== '+')
+                return undefined;
+            const left = foldString(node.left);
+            const right = foldString(node.right);
+            return left === undefined || right === undefined ? undefined : left + right;
+        }
+        default:
+            return undefined;
+    }
+}
+function resolveGroups(value) {
+    const expression = expressionOf(value);
+    if ((expression === null || expression === void 0 ? void 0 : expression.type) !== 'ObjectExpression' || expression.properties.length !== 1)
+        return undefined;
+    const [property] = expression.properties;
+    if ((property === null || property === void 0 ? void 0 : property.type) !== 'Property' || property.computed)
+        return undefined;
+    const key = property.key.type === 'Identifier' ? property.key.name : undefined;
+    const literalKey = property.key.type === 'Literal' ? property.key.value : undefined;
+    if ((key !== null && key !== void 0 ? key : literalKey) !== 'groups' || property.value.type !== 'ArrayExpression')
+        return undefined;
+    const groups = property.value.elements.map((element) => { var _a, _b; return (_b = (_a = foldString(element)) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : ''; });
+    return groups.length > 0 && groups.every(Boolean) ? [...new Set(groups)] : undefined;
+}
+function mayOverrideFor(attr) {
+    if (attr.type !== 'mdxJsxExpressionAttribute')
+        return false;
+    const expression = expressionOf(attr);
+    const spread = (expression === null || expression === void 0 ? void 0 : expression.type) === 'ObjectExpression' && expression.properties.length === 1
+        ? expression.properties[0]
+        : undefined;
+    if ((spread === null || spread === void 0 ? void 0 : spread.type) !== 'SpreadElement' || spread.argument.type !== 'ObjectExpression')
+        return true;
+    return spread.argument.properties.some((property) => {
+        if (property.type !== 'Property' || property.computed)
+            return true;
+        const key = property.key.type === 'Identifier' ? property.key.name : undefined;
+        const literalKey = property.key.type === 'Literal' ? property.key.value : undefined;
+        return (key !== null && key !== void 0 ? key : literalKey) === 'for';
+    });
+}
 export function resolveVisibilityFor(node) {
-    var _a;
+    var _a, _b;
     let invalidRaw;
     let sawDynamic = false;
     let sawAttribute = false;
+    const lastFor = node.attributes.findLastIndex((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'for');
+    if (node.attributes.slice(lastFor + 1).some(mayOverrideFor))
+        return { kind: 'dynamic' };
     for (const attr of node.attributes) {
         if (attr.type !== 'mdxJsxAttribute' || attr.name !== 'for')
             continue;
         sawAttribute = true;
         if (typeof attr.value === 'string') {
-            if (attr.value === 'humans' || attr.value === 'agents') {
+            if (isVisibilityAudience(attr.value)) {
                 return { kind: 'audience', audience: attr.value };
             }
             invalidRaw !== null && invalidRaw !== void 0 ? invalidRaw : (invalidRaw = attr.value);
@@ -24,18 +95,32 @@ export function resolveVisibilityFor(node) {
         if (attr.value && typeof attr.value === 'object') {
             if ('value' in attr.value && typeof attr.value.value === 'string') {
                 const raw = attr.value.value.trim();
+                const folded = foldString(expressionOf(attr.value));
+                if (folded !== undefined) {
+                    if (isVisibilityAudience(folded))
+                        return { kind: 'audience', audience: folded };
+                    invalidRaw !== null && invalidRaw !== void 0 ? invalidRaw : (invalidRaw = folded);
+                    continue;
+                }
                 const quoted = raw.match(/^(["'`])((?:\\.|(?!\1)[^\\])*)\1$/);
                 if (quoted) {
                     const inner = (_a = quoted[2]) !== null && _a !== void 0 ? _a : '';
                     const isTemplateWithInterpolation = quoted[1] === '`' && inner.includes('${');
                     if (!isTemplateWithInterpolation) {
-                        if (inner === 'humans' || inner === 'agents') {
+                        if (isVisibilityAudience(inner)) {
                             return { kind: 'audience', audience: inner };
                         }
                         invalidRaw !== null && invalidRaw !== void 0 ? invalidRaw : (invalidRaw = inner);
                         continue;
                     }
                 }
+                const groups = resolveGroups(attr.value);
+                if (groups)
+                    return { kind: 'groups', groups };
+                if (((_b = expressionOf(attr.value)) === null || _b === void 0 ? void 0 : _b.type) === 'ObjectExpression' || raw.startsWith('{')) {
+                    invalidRaw !== null && invalidRaw !== void 0 ? invalidRaw : (invalidRaw = raw);
+                    continue;
+                }
             }
             sawDynamic = true;
         }
@@ -52,6 +137,8 @@ export function isHiddenFromHumans(resolution) {
     switch (resolution.kind) {
         case 'audience':
             return resolution.audience === 'agents';
+        case 'groups':
+            return false;
         case 'invalid':
         case 'missing':
             return true;
@@ -59,6 +146,34 @@ export function isHiddenFromHumans(resolution) {
             return false;
     }
 }
+export function isHiddenFromAgents(resolution) {
+    switch (resolution.kind) {
+        case 'audience':
+            return resolution.audience === 'humans' || resolution.audience === 'signed-in';
+        case 'groups':
+        case 'invalid':
+        case 'dynamic':
+        case 'missing':
+            return true;
+    }
+}
+export function toVisibilityAuthRule(resolution) {
+    if (resolution.kind === 'groups')
+        return { groups: resolution.groups };
+    if (resolution.kind !== 'audience')
+        return undefined;
+    if (resolution.audience === 'signed-in' || resolution.audience === 'signed-out') {
+        return resolution.audience;
+    }
+    return undefined;
+}
+export function matchesVisibilityAuthRule(rule, viewer) {
+    if (rule === 'signed-in')
+        return viewer.signedIn;
+    if (rule === 'signed-out')
+        return !viewer.signedIn;
+    return viewer.signedIn && rule.groups.some((group) => viewer.groups.includes(group));
+}
 // `export * from` is intentionally ignored: it exposes no statically-knowable
 // names and creates no page-local JSX bindings in MDX, so there is nothing to
 // collect.
@@ -163,9 +278,7 @@ function collectJsxUsage(nodes, insideHumans, hiddenNames, visibleNames) {
         if (isMdxJsxElement(node)) {
             if (node.name === 'Visibility') {
                 const resolution = resolveVisibilityFor(node);
-                const isHidden = resolution.kind === 'invalid' ||
-                    (resolution.kind === 'audience' && resolution.audience === 'humans');
-                if (isHidden)
+                if (isHiddenFromAgents(resolution))
                     childInsideHumans = true;
             }
             else {
@@ -206,15 +319,14 @@ function transformNode(node, esmToStrip) {
     }
     if (isMdxJsxElement(node) && node.name === 'Visibility') {
         const resolution = resolveVisibilityFor(node);
-        if (resolution.kind === 'audience' && resolution.audience === 'humans') {
+        if (resolution.kind === 'invalid') {
+            console.warn(`<Visibility for="${resolution.raw}"> has an unknown audience — expected ${VISIBILITY_FOR_EXPECTED}. The content was removed from the markdown output.`);
             return [];
         }
-        if (resolution.kind === 'audience' && resolution.audience === 'agents') {
-            return transformChildren(node.children, esmToStrip);
-        }
-        if (resolution.kind === 'invalid') {
-            console.warn(`<Visibility for="${resolution.raw}"> has an unknown audience — expected "humans" or "agents". The content was removed from the markdown output.`);
+        if (isHiddenFromAgents(resolution))
             return [];
+        if (resolution.kind === 'audience') {
+            return transformChildren(node.children, esmToStrip);
         }
     }
     if ('children' in node && Array.isArray(node.children)) {

package/dist/navigation/groupAccess.js

@@ -1,6 +1,12 @@
-import { pageGroupsSchema } from '@mintlify/validation';
+import * as v from 'valibot';
 export const WILDCARD_GROUP = '*';
-export const isPageGroups = (value) => pageGroupsSchema.safeParse(value).success;
+const groupNameSchema = v.pipe(v.string(), v.minLength(1));
+const groupRuleSchema = v.strictObject({
+    includes: v.optional(v.pipe(v.array(groupNameSchema), v.minLength(1))),
+    excludes: v.optional(v.pipe(v.array(groupNameSchema), v.check((excludes) => !excludes.includes(WILDCARD_GROUP)))),
+});
+const pageGroupsSchema = v.union([v.array(groupNameSchema), v.array(groupRuleSchema)]);
+export const isPageGroups = (value) => v.is(pageGroupsSchema, value);
 const isStringArray = (groups) => groups.every((entry) => typeof entry === 'string');
 const DENY_ALL = { includes: [], excludes: [] };
 export function normalizeGroups(groups) {