@mintlify/cli 4.0.1433 → 4.0.1437

package/bin/vendor/converter.js

@@ -1033,6 +1033,7 @@ function getImageWidthFromStyle(style) {
 }
 
 // ../editor/dist/converter/parse/handlers/media.js
+var isAttributeRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function parseImgNode(node, spreadAttrs = false) {
   const attributes = parseMdxAttributes(node.attributes);
   const className = attributes.className;
@@ -1042,7 +1043,7 @@ function parseImgNode(node, spreadAttrs = false) {
   }
   const style = attributes.style;
   let width;
-  if (style && typeof style === "object") {
+  if (isAttributeRecord(style)) {
     width = getImageWidthFromStyle(style);
   }
   return {
@@ -1050,8 +1051,18 @@ function parseImgNode(node, spreadAttrs = false) {
     attrs: { imgAttributes: spreadAttrs ? Object.assign({}, attributes) : attributes, align, width }
   };
 }
+function isVideoSourceElement(child) {
+  return (child.type === "mdxJsxTextElement" || child.type === "mdxJsxFlowElement") && child.name === "source";
+}
 function parseVideoNode(node) {
-  const sources = node.children.filter((child) => (child.type === "mdxJsxTextElement" || child.type === "mdxJsxFlowElement") && child.name === "source").map((child) => parseMdxAttributes(child.attributes));
+  const editable = node.children.every((child) => isVideoSourceElement(child) || child.type === "text" && child.value.trim() === "");
+  if (!editable) {
+    return {
+      type: node.type === "mdxJsxTextElement" ? BLOCK_TYPES.inlineUnknownTag : BLOCK_TYPES.unknownTag,
+      attrs: { mdxJsxNode: node }
+    };
+  }
+  const sources = node.children.filter(isVideoSourceElement).map((child) => parseMdxAttributes(child.attributes));
   return {
     type: BLOCK_TYPES.video,
     attrs: {
@@ -1061,9 +1072,15 @@ function parseVideoNode(node) {
   };
 }
 var DARK_ONLY_CLASSES = /* @__PURE__ */ new Set(["hidden", "dark:block"]);
+var LIGHT_ONLY_CLASSES = /* @__PURE__ */ new Set(["dark:hidden"]);
+function readImageAttributes(node) {
+  var _a;
+  const attributes = (_a = node.attrs) === null || _a === void 0 ? void 0 : _a.imgAttributes;
+  return isAttributeRecord(attributes) ? attributes : null;
+}
 function getImageClassName(node) {
-  var _a, _b;
-  const className = (_b = (_a = node.attrs) === null || _a === void 0 ? void 0 : _a.imgAttributes) === null || _b === void 0 ? void 0 : _b.className;
+  var _a;
+  const className = (_a = readImageAttributes(node)) === null || _a === void 0 ? void 0 : _a.className;
   return typeof className === "string" ? className : void 0;
 }
 function isDarkOnlyImage(node) {
@@ -1083,18 +1100,35 @@ function isLightOnlyImage(node) {
     return false;
   return className.split(/\s+/).includes("dark:hidden");
 }
-function stripThemeClasses(className) {
-  const cleaned = className.split(/\s+/).filter((c) => !DARK_ONLY_CLASSES.has(c) && c !== "dark:hidden").join(" ").trim();
+function stripThemeClasses(className, role) {
+  if (!className)
+    return void 0;
+  const themeClasses = role === "dark" ? DARK_ONLY_CLASSES : LIGHT_ONLY_CLASSES;
+  const cleaned = className.split(/\s+/).filter((c) => !themeClasses.has(c)).join(" ").trim();
   return cleaned || void 0;
 }
+function nonThemeAttributeEntries(attrs2) {
+  return Object.entries(attrs2).filter(([key]) => key !== "src" && key !== "className").sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+}
+function canMergeAsThemePair(lightImgAttrs, darkImgAttrs, lightClassName, darkClassName) {
+  const lightBase = stripThemeClasses(lightClassName, "light");
+  const darkBase = stripThemeClasses(darkClassName, "dark");
+  const lightBaseWithoutBlock = (lightBase === null || lightBase === void 0 ? void 0 : lightBase.split(/\s+/).filter((c) => c !== "block").join(" ").trim()) || void 0;
+  if (darkBase !== lightBase && darkBase !== lightBaseWithoutBlock) {
+    return false;
+  }
+  const lightEntries = nonThemeAttributeEntries(lightImgAttrs);
+  const darkEntries = nonThemeAttributeEntries(darkImgAttrs);
+  return lightEntries.length === darkEntries.length && JSON.stringify(lightEntries) === JSON.stringify(darkEntries);
+}
 function mergeDarkLightImagePairs(nodes2) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+  var _a, _b, _c, _d, _e, _f;
   const result = [];
   let i = 0;
   while (i < nodes2.length) {
-    if (i + 1 < nodes2.length) {
-      const current = nodes2[i];
-      const next = nodes2[i + 1];
+    const current = nodes2[i];
+    const next = nodes2[i + 1];
+    if (current && next) {
       let darkNode;
       let lightNode;
       if (isDarkOnlyImage(current) && isLightOnlyImage(next)) {
@@ -1104,12 +1138,12 @@ function mergeDarkLightImagePairs(nodes2) {
         lightNode = current;
         darkNode = next;
       }
-      if (darkNode && lightNode) {
-        const darkImgAttrs = (_a = darkNode.attrs) === null || _a === void 0 ? void 0 : _a.imgAttributes;
-        const lightImgAttrs = (_b = lightNode.attrs) === null || _b === void 0 ? void 0 : _b.imgAttributes;
-        const darkSrc = darkImgAttrs.src;
-        const lightSrc = lightImgAttrs.src;
-        const baseClassName = stripThemeClasses((_d = (_c = getImageClassName(lightNode)) !== null && _c !== void 0 ? _c : getImageClassName(darkNode)) !== null && _d !== void 0 ? _d : "");
+      const darkImgAttrs = darkNode ? readImageAttributes(darkNode) : null;
+      const lightImgAttrs = lightNode ? readImageAttributes(lightNode) : null;
+      const darkSrc = darkImgAttrs === null || darkImgAttrs === void 0 ? void 0 : darkImgAttrs.src;
+      const lightSrc = lightImgAttrs === null || lightImgAttrs === void 0 ? void 0 : lightImgAttrs.src;
+      if (darkNode && lightNode && darkImgAttrs && lightImgAttrs && typeof darkSrc === "string" && typeof lightSrc === "string" && canMergeAsThemePair(lightImgAttrs, darkImgAttrs, getImageClassName(lightNode), getImageClassName(darkNode))) {
+        const baseClassName = stripThemeClasses(getImageClassName(lightNode), "light");
         const mergedImgAttrs = Object.assign({}, lightImgAttrs);
         delete mergedImgAttrs.src;
         if (baseClassName) {
@@ -1123,15 +1157,16 @@ function mergeDarkLightImagePairs(nodes2) {
             imgAttributes: mergedImgAttrs,
             lightSrc,
             darkSrc,
-            align: (_f = (_e = lightNode.attrs) === null || _e === void 0 ? void 0 : _e.align) !== null && _f !== void 0 ? _f : (_g = darkNode.attrs) === null || _g === void 0 ? void 0 : _g.align,
-            width: (_j = (_h = lightNode.attrs) === null || _h === void 0 ? void 0 : _h.width) !== null && _j !== void 0 ? _j : (_k = darkNode.attrs) === null || _k === void 0 ? void 0 : _k.width
+            align: (_b = (_a = lightNode.attrs) === null || _a === void 0 ? void 0 : _a.align) !== null && _b !== void 0 ? _b : (_c = darkNode.attrs) === null || _c === void 0 ? void 0 : _c.align,
+            width: (_e = (_d = lightNode.attrs) === null || _d === void 0 ? void 0 : _d.width) !== null && _e !== void 0 ? _e : (_f = darkNode.attrs) === null || _f === void 0 ? void 0 : _f.width
           }
         });
         i += 2;
         continue;
       }
     }
-    result.push(nodes2[i]);
+    if (current)
+      result.push(current);
     i++;
   }
   return result;
@@ -1158,7 +1193,7 @@ function convertToInlineImage(node) {
     let width = 100;
     if (attributes.width && typeof attributes.width === "number") {
       width = attributes.width;
-    } else if (attributes.style && typeof attributes.style === "object") {
+    } else if (isAttributeRecord(attributes.style)) {
       const styleWidth = getImageWidthFromStyle(attributes.style);
       if (styleWidth)
         width = styleWidth;
@@ -2713,10 +2748,10 @@ function serializeJsxAttribute(attrs2, key, value) {
   const serialized = serializePropValue(value);
   return serialized ? `${key}=${serialized}` : null;
 }
-var isAttributeRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isAttributeRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function getNamedExpressionAttr(attrs2, key) {
   const raw = attrs2[NAMED_EXPRESSION_ATTRS_KEY];
-  if (!isAttributeRecord(raw))
+  if (!isAttributeRecord2(raw))
     return void 0;
   const value = raw[key];
   return typeof value === "string" ? value : void 0;
@@ -2809,7 +2844,7 @@ function renderImage(state, node) {
       return;
     }
     const hasExtraAttrs = Object.keys(imgAttributes).some((attr) => attr !== "src" && attr !== "alt" && attr !== "title");
-    if (hasExtraAttrs || width || align) {
+    if (hasExtraAttrs || width || align || !fitsMarkdownImageValues(Object.assign(Object.assign({}, imgAttributes), { src }))) {
       const finalAttrs = Object.assign(Object.assign({}, imgAttributes), { src });
       if (align) {
         finalAttrs["className"] = addAlignClass(finalAttrs["className"], align);
@@ -2869,11 +2904,27 @@ function writeMarkdownImage(state, imgAttributes, src) {
     state.write(`![${alt}](${escapedSrc})`);
   }
 }
+var MARKDOWN_UNSAFE_SRC = /[\s<>\u0000-\u001F]/;
+var MARKDOWN_UNSAFE_TEXT = /[\r\n]/;
+function fitsMarkdownImageValues(attrs2) {
+  const src = attrs2["src"];
+  if (typeof src !== "string" || !src || MARKDOWN_UNSAFE_SRC.test(src))
+    return false;
+  const alt = attrs2["alt"];
+  if (typeof alt === "string" && MARKDOWN_UNSAFE_TEXT.test(alt))
+    return false;
+  const title = attrs2["title"];
+  if (typeof title === "string" && MARKDOWN_UNSAFE_TEXT.test(title))
+    return false;
+  return true;
+}
 function fitsMarkdownImageSyntax(node, attrs2) {
   if (!node.marks.some((mark) => mark.type.name === "link"))
     return false;
   if (typeof attrs2["src"] !== "string" || !attrs2["src"])
     return false;
+  if (!fitsMarkdownImageValues(attrs2))
+    return false;
   return Object.entries(attrs2).every(([key, value]) => key === "src" || key === "alt" || key === "title" || value == null);
 }
 function renderInlineImage(state, node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/cli",
-  "version": "4.0.1433",
+  "version": "4.0.1437",
   "description": "The Mintlify CLI",
   "engines": {
     "node": ">=18.0.0"
@@ -45,12 +45,13 @@
   },
   "dependencies": {
     "@inquirer/prompts": "7.9.0",
-    "@mintlify/common": "1.0.1110",
-    "@mintlify/link-rot": "3.0.1312",
-    "@mintlify/models": "0.0.350",
-    "@mintlify/prebuild": "1.0.1264",
-    "@mintlify/previewing": "4.0.1336",
-    "@mintlify/validation": "0.1.841",
+    "@mintlify/agent-harness": "0.0.3",
+    "@mintlify/common": "1.0.1111",
+    "@mintlify/link-rot": "3.0.1313",
+    "@mintlify/models": "0.0.351",
+    "@mintlify/prebuild": "1.0.1265",
+    "@mintlify/previewing": "4.0.1337",
+    "@mintlify/validation": "0.1.842",
     "adm-zip": "0.6.0",
     "chalk": "5.2.0",
     "color": "4.2.3",
@@ -82,7 +83,7 @@
     "keytar": "7.9.0"
   },
   "devDependencies": {
-    "@mintlify/editor": "0.0.326",
+    "@mintlify/editor": "0.0.328",
     "@mintlify/ts-config": "2.0.2",
     "@tsconfig/recommended": "1.0.2",
     "@types/detect-port": "1.3.2",
@@ -101,5 +102,5 @@
     "vitest": "2.1.9",
     "vitest-mock-process": "1.0.4"
   },
-  "gitHead": "b35172bff15786ea8cfd4e8e00f868046e5e1ff8"
+  "gitHead": "246494b8852335337e48cd0518b54abb2fb3f774"
 }

package/src/cli.tsx

@@ -44,6 +44,7 @@ import { login } from './login.js';
 import { logout } from './logout.js';
 import { mdxLinter } from './mdxLinter.js';
 import { createTelemetryMiddleware } from './middlewares/telemetryMiddleware.js';
+import { mintTestHandler } from './mintTest.js';
 import { checkOpenApiFile, getOpenApiFilenamesFromDocsConfig } from './openApiCheck.js';
 import { resolveExplicitFiles } from './resolveFiles.js';
 import { scoreHandler } from './score/index.js';
@@ -85,15 +86,18 @@ const showWelcome = async (packageName: string): Promise<void> => {
 };
 
 export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
-  if (shouldShowWelcome(hideBin(process.argv))) {
+  const commandArguments = hideBin(process.argv);
+  if (shouldShowWelcome(commandArguments)) {
     return showWelcome(packageName);
   }
 
   const telemetryMiddleware = createTelemetryMiddleware();
-  render(<Logs />);
+  if (commandArguments.find((argument) => !argument.startsWith('-')) !== 'test') {
+    render(<Logs />);
+  }
 
   return (
-    yargs(hideBin(process.argv))
+    yargs(commandArguments)
       .scriptName(packageName)
       .option('telemetry', {
         type: 'boolean',
@@ -239,6 +243,14 @@ export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
           });
         }
       )
+      .command(
+        'test',
+        'Test runnable code blocks with a local coding agent',
+        (yargs) => yargs.usage('usage: mint test'),
+        async () => {
+          await mintTestHandler();
+        }
+      )
       .command(
         'export',
         'Export a static site for air-gapped deployment',
@@ -762,12 +774,6 @@ export const cli = ({ packageName = 'mint' }: { packageName?: string }) => {
         () => undefined,
         comingSoon('ai', packageName)
       )
-      .command(
-        'test',
-        '[Coming soon] Test your documentation (run mint test to vote)',
-        () => undefined,
-        comingSoon('test', packageName)
-      )
       .command(
         'mcp',
         '[Coming soon] MCP server for documentation (run mint mcp to vote)',

package/src/mintTest.tsx

@@ -0,0 +1,102 @@
+import {
+  DEFAULT_COMMAND_TIMEOUT_MS,
+  DEFAULT_CONCURRENCY,
+  clearRunSave,
+  discoverCodeBlocks,
+  loadRunSave,
+  runCodeTests,
+  type RunSave,
+} from '@mintlify/agent-harness';
+import path from 'node:path';
+
+import { CMD_EXEC_PATH, findDocsRoot, isAI, terminate } from './helpers.js';
+import { getAccessToken } from './keyring.js';
+import { fileInNavPaths, loadDocsNavScope } from './mintTestNav.js';
+import { countReport, formatDuration, runMintTestUi } from './mintTestUi.js';
+import { getCliStatus } from './status.js';
+
+export async function mintTestHandler(): Promise<void> {
+  try {
+    const accessToken = await getAccessToken().catch(() => null);
+    if (!accessToken) {
+      process.stderr.write('not logged in. Run `mint login` to authenticate.\n');
+      await terminate(1);
+      return;
+    }
+    const cliStatus = await getCliStatus(accessToken);
+    if (cliStatus?.org.name.toLowerCase() !== 'mintlify') {
+      process.stderr.write('mint test is not available for your organization.\n');
+      await terminate(1);
+      return;
+    }
+    const targetPath = await findDocsRoot(CMD_EXEC_PATH);
+    const interactive =
+      process.stdin.isTTY === true &&
+      process.stdout.isTTY === true &&
+      !isAI() &&
+      !process.env.CI &&
+      process.env.CLI_TEST_MODE !== 'true';
+
+    const { docsRoot, pages: discoveredPages } = await discoverCodeBlocks(targetPath);
+    const scope = await loadDocsNavScope(docsRoot);
+    const pages = scope
+      ? discoveredPages.filter((page) => fileInNavPaths(page.file, scope.navPaths))
+      : discoveredPages;
+    const autoSelectedFiles = (
+      scope ? pages.filter((page) => fileInNavPaths(page.file, scope.autoSelectedPaths)) : pages
+    ).map((page) => page.file);
+    const totalPages = scope ? scope.navPaths.size : pages.length;
+    const outputDirectory = path.join(docsRoot, 'tests', 'mint-test');
+
+    let save: RunSave | null = await loadRunSave(outputDirectory);
+    if (save) {
+      const known = new Set(pages.map((page) => page.file));
+      const selectedFiles = save.selectedFiles.filter((file) => known.has(file));
+      if (selectedFiles.length === 0) {
+        await clearRunSave(outputDirectory);
+        save = null;
+      } else {
+        save = { ...save, selectedFiles };
+      }
+    }
+
+    if (interactive) {
+      const exitCode = await runMintTestUi({
+        targetPath,
+        docsRoot,
+        pages,
+        autoSelectedFiles,
+        totalPages,
+        save,
+      });
+      await terminate(exitCode);
+      return;
+    }
+
+    if (save) process.stdout.write(`resuming run ${save.runId}\n`);
+    const report = await runCodeTests({
+      path: targetPath,
+      agents: save?.agents ?? ['claude'],
+      model: save?.model ?? 'claude-opus-4-8',
+      selectedFiles: save?.selectedFiles ?? autoSelectedFiles,
+      outputDirectory,
+      runId: save?.runId ?? null,
+      concurrency: DEFAULT_CONCURRENCY,
+      commandTimeoutMs: DEFAULT_COMMAND_TIMEOUT_MS,
+      signal: new AbortController().signal,
+      onTaskUpdate: () => {},
+    });
+    const counts = countReport(report.tasks);
+    process.stdout.write(
+      `mint test ${report.status}: ${counts.passed} passed, ${counts.failed} failed, ${counts.agentErrors} agent errors\n`
+    );
+    process.stdout.write(`finished in ${formatDuration(report.durationMs)}\n`);
+    process.stdout.write(`report: ${report.reportPath}\n`);
+    await terminate(report.status === 'passed' ? 0 : 1);
+  } catch (error) {
+    process.stderr.write(
+      `mint test failed: ${error instanceof Error ? error.message : 'unknown error'}\n`
+    );
+    await terminate(1);
+  }
+}

package/src/mintTestNav.ts

@@ -0,0 +1,31 @@
+import { getAllPathsInDocsNav } from '@mintlify/common';
+import { getConfigObj } from '@mintlify/prebuild';
+import type { DocsConfig, NavigationConfig } from '@mintlify/validation';
+
+export interface DocsNavScope {
+  navPaths: Set<string>;
+  autoSelectedPaths: Set<string>;
+}
+
+export async function loadDocsNavScope(docsRoot: string): Promise<DocsNavScope | null> {
+  const config = (await getConfigObj(docsRoot, 'docs').catch(() => null)) as DocsConfig | null;
+  const navigation = config?.navigation;
+  if (!navigation) return null;
+  const navPaths = new Set(getAllPathsInDocsNav(navigation));
+  if (navPaths.size === 0) return null;
+  const firstLanguage =
+    'languages' in navigation ? (navigation.languages[0] as NavigationConfig | undefined) : null;
+  const autoSelectedPaths = firstLanguage ? new Set(getAllPathsInDocsNav(firstLanguage)) : navPaths;
+  return { navPaths, autoSelectedPaths };
+}
+
+export function navCandidatesForFile(file: string): string[] {
+  const base = file.replace(/\.mdx?$/i, '');
+  const candidates = [base];
+  if (base.endsWith('/index')) candidates.push(base.slice(0, -'/index'.length));
+  return candidates;
+}
+
+export function fileInNavPaths(file: string, paths: Set<string>): boolean {
+  return navCandidatesForFile(file).some((candidate) => paths.has(candidate));
+}

package/src/mintTestTree.ts

@@ -0,0 +1,134 @@
+import type { DocsPage } from '@mintlify/agent-harness';
+
+export type ScopeSelectionState = 'all' | 'some' | 'none';
+
+export interface ScopeTreeRow {
+  id: string;
+  kind: 'directory' | 'file';
+  label: string;
+  depth: number;
+  file?: string;
+  blockCount: number;
+  selectableFiles: string[];
+  selection: ScopeSelectionState;
+  expanded?: boolean;
+}
+
+interface TreeNode {
+  id: string;
+  kind: 'directory' | 'file';
+  label: string;
+  file?: string;
+  blockCount: number;
+  children: TreeNode[];
+}
+
+function buildTree(pages: DocsPage[]): TreeNode {
+  const root: TreeNode = { id: 'dir:', kind: 'directory', label: '.', blockCount: 0, children: [] };
+  const directories = new Map<string, TreeNode>([['', root]]);
+
+  for (const page of pages) {
+    const parts = page.file.split('/');
+    let parent = root;
+    let directoryPath = '';
+    for (const part of parts.slice(0, -1)) {
+      directoryPath = directoryPath ? `${directoryPath}/${part}` : part;
+      let directory = directories.get(directoryPath);
+      if (!directory) {
+        directory = {
+          id: `dir:${directoryPath}`,
+          kind: 'directory',
+          label: part,
+          blockCount: 0,
+          children: [],
+        };
+        directories.set(directoryPath, directory);
+        parent.children.push(directory);
+      }
+      parent = directory;
+    }
+
+    parent.children.push({
+      id: `file:${page.file}`,
+      kind: 'file',
+      label: parts[parts.length - 1] ?? page.file,
+      file: page.file,
+      blockCount: page.blockCount,
+      children: [],
+    });
+  }
+
+  const sumBlocks = (node: TreeNode): number => {
+    if (node.kind === 'file') return node.blockCount;
+    node.blockCount = node.children.reduce((total, child) => total + sumBlocks(child), 0);
+    return node.blockCount;
+  };
+  sumBlocks(root);
+
+  const sortChildren = (node: TreeNode): void => {
+    node.children.sort((left, right) => {
+      if (left.kind !== right.kind) return left.kind === 'directory' ? -1 : 1;
+      return left.label.localeCompare(right.label);
+    });
+    for (const child of node.children) sortChildren(child);
+  };
+  sortChildren(root);
+  return root;
+}
+
+function descendantFiles(node: TreeNode): string[] {
+  if (node.kind === 'file') return node.file ? [node.file] : [];
+  return node.children.flatMap(descendantFiles);
+}
+
+function selectionState(files: string[], selectedFiles: ReadonlySet<string>): ScopeSelectionState {
+  if (files.length === 0) return 'none';
+  const selectedCount = files.filter((file) => selectedFiles.has(file)).length;
+  if (selectedCount === 0) return 'none';
+  return selectedCount === files.length ? 'all' : 'some';
+}
+
+export function visibleScopeRows(
+  pages: DocsPage[],
+  expandedDirectories: ReadonlySet<string>,
+  selectedFiles: ReadonlySet<string>
+): ScopeTreeRow[] {
+  const root = buildTree(pages);
+  const rows: ScopeTreeRow[] = [];
+
+  const visit = (node: TreeNode, depth: number) => {
+    const files = descendantFiles(node);
+    const expanded = node.kind === 'directory' ? expandedDirectories.has(node.id) : undefined;
+    rows.push({
+      id: node.id,
+      kind: node.kind,
+      label: node.label,
+      depth,
+      ...(node.file ? { file: node.file } : {}),
+      blockCount: node.blockCount,
+      selectableFiles: files,
+      selection: selectionState(files, selectedFiles),
+      ...(expanded !== undefined ? { expanded } : {}),
+    });
+    if (node.kind === 'directory' && expanded) {
+      for (const child of node.children) visit(child, depth + 1);
+    }
+  };
+
+  for (const child of root.children) visit(child, 0);
+  return rows;
+}
+
+export function toggleScopeSelection(
+  selectedFiles: ReadonlySet<string>,
+  row: ScopeTreeRow
+): Set<string> {
+  const next = new Set(selectedFiles);
+  if (row.selectableFiles.length === 0) return next;
+  const shouldSelect = row.selectableFiles.some((file) => !next.has(file));
+  for (const file of row.selectableFiles) {
+    if (shouldSelect) next.add(file);
+    else next.delete(file);
+  }
+  return next;
+}