@inspecto-dev/cli 0.2.0-alpha.2 → 0.2.0-alpha.4

package/src/commands/init.ts

@@ -18,7 +18,7 @@ import { detectProviders, type ProviderDetection } from '../detect/provider.js'
 import { injectPlugin } from '../inject/ast-injector.js'
 import { updateGitignore } from '../inject/gitignore.js'
 import { installExtension } from '../inject/extension.js'
-import type { InitOptions, InstallLock, Mutation } from '../types.js'
+import type { InitOptions, InstallLock, Mutation, BuildToolDetection } from '../types.js'
 import {
   promptIDEChoice,
   promptProviderChoice,
@@ -30,6 +30,29 @@ import { printNextJsManualInstructions, printNuxtManualInstructions } from '../i
 export async function init(options: InitOptions): Promise<void> {
   const root = process.cwd()
   const mutations: Mutation[] = []
+  const normalizedPackages = normalizePackageList(options.packages)
+
+  const verifiedPackages: string[] = []
+  for (const pkg of normalizedPackages) {
+    if (!pkg) {
+      // Empty string represents the workspace root
+      verifiedPackages.push(pkg)
+      continue
+    }
+
+    const absolutePath = path.join(root, pkg)
+    if (await exists(absolutePath)) {
+      verifiedPackages.push(pkg)
+    } else {
+      log.warn(`Package path "${pkg}" not found (skipping)`)
+      log.hint('Ensure --packages values are relative to the project root')
+    }
+  }
+
+  if (normalizedPackages.length > 0 && verifiedPackages.length === 0) {
+    log.error('No valid packages found from --packages input')
+    return
+  }
 
   log.header('Inspecto Setup')
 
@@ -44,7 +67,7 @@ export async function init(options: InitOptions): Promise<void> {
   const [pm, frameworkResult, buildResult, ideProbe, providerProbe] = await Promise.all([
     detectPackageManager(root),
     detectFrameworks(root),
-    detectBuildTools(root),
+    detectBuildTools(root, verifiedPackages.length > 0 ? verifiedPackages : undefined),
     detectIDE(root),
     detectProviders(root),
   ])
@@ -57,12 +80,11 @@ export async function init(options: InitOptions): Promise<void> {
     log.success(`Detected framework: ${frameworkResult.supported.join(', ')}`)
   }
 
-  const hasUnsupportedFramework = frameworkResult.unsupported.length > 0
-  const hasNoFramework =
-    frameworkResult.supported.length === 0 && frameworkResult.unsupported.length === 0
+  const isSupported = frameworkResult.supported.length > 0
+  const hasUnsupported = frameworkResult.unsupported.length > 0
 
-  if (hasUnsupportedFramework || hasNoFramework) {
-    if (hasUnsupportedFramework) {
+  if (!isSupported) {
+    if (hasUnsupported) {
       const names = frameworkResult.unsupported.map(f => f.name).join(', ')
       log.warn(`Detected ${names} — not supported in v1 (React / Vue only)`)
     } else {
@@ -79,10 +101,22 @@ export async function init(options: InitOptions): Promise<void> {
     } else {
       log.warn('Continuing anyway (--force)')
     }
+  } else if (hasUnsupported) {
+    const names = frameworkResult.unsupported.map(f => f.name).join(', ')
+    log.hint(
+      `Note: Inspecto will be configured for ${frameworkResult.supported.join(', ')}. Other detected frameworks (${names}) will be ignored.`,
+    )
   }
 
   // Build tool detection
   let manualConfigRequiredFor = ''
+  if (verifiedPackages.length > 0 && buildResult.supported.length === 0) {
+    log.warn(
+      `No supported build configs detected for: ${verifiedPackages.map(pkg => (pkg ? pkg : '.')).join(', ')}`,
+    )
+    log.hint('Double-check the --packages values or run without the flag to scan the repo root')
+  }
+
   if (buildResult.supported.length > 0) {
     buildResult.supported.forEach(bt => log.success(`Detected: ${bt.label}`))
   }
@@ -97,7 +131,7 @@ export async function init(options: InitOptions): Promise<void> {
     log.hint('current version supports: Vite, Webpack, Rspack, esbuild, Rollup')
     log.hint('Dependency will be installed but plugin injection will be skipped')
     log.hint(
-      'Please refer to the manual setup guide: https://inspecto.dev/docs/getting-started/manual-setup',
+      'Please refer to the manual setup guide: https://inspecto-dev.github.io/inspecto/guide/manual-installation',
     )
   }
 
@@ -173,22 +207,54 @@ export async function init(options: InitOptions): Promise<void> {
   // ---- Step 4: Inject plugin into build config ----
   let injectionFailed = false
   if (buildResult.supported.length > 0) {
-    let target = resolveInjectionTarget(buildResult.supported)
+    if (verifiedPackages.length > 0) {
+      const targets = buildResult.supported.filter(detection =>
+        matchesAnyPackage(detection, verifiedPackages),
+      )
 
-    if (target === 'ambiguous') {
-      target = await promptConfigChoice(buildResult.supported)
-    }
+      const unmatchedPackages = verifiedPackages.filter(
+        pkg => !buildResult.supported.some(detection => matchesPackage(detection, pkg)),
+      )
 
-    if (target) {
-      const result = await injectPlugin(root, target, options.dryRun)
-      if (result.success) {
-        mutations.push(...result.mutations)
-      } else {
+      if (unmatchedPackages.length > 0) {
+        log.warn(
+          `No supported build configs detected for: ${unmatchedPackages
+            .map(pkg => (pkg ? pkg : '.'))
+            .join(', ')}`,
+        )
+        log.hint('Check the package paths or run without --packages to inspect the repo root')
+      }
+
+      if (targets.length === 0) {
         injectionFailed = true
       }
+
+      for (const target of targets) {
+        const result = await injectPlugin(root, target, options.dryRun)
+        if (result.success) {
+          mutations.push(...result.mutations)
+        } else {
+          injectionFailed = true
+        }
+      }
     } else {
-      injectionFailed = true
-      log.warn('Skipping plugin injection (manual configuration required)')
+      let target = resolveInjectionTarget(buildResult.supported)
+
+      if (target === 'ambiguous') {
+        target = await promptConfigChoice(buildResult.supported)
+      }
+
+      if (target) {
+        const result = await injectPlugin(root, target, options.dryRun)
+        if (result.success) {
+          mutations.push(...result.mutations)
+        } else {
+          injectionFailed = true
+        }
+      } else {
+        injectionFailed = true
+        log.warn('Skipping plugin injection (manual configuration required)')
+      }
     }
   }
 
@@ -325,3 +391,33 @@ export async function init(options: InitOptions): Promise<void> {
     log.ready('Ready! Hold Alt + Click any element to inspect.')
   }
 }
+
+function normalizePackageList(packages?: string[]): string[] {
+  if (!packages || packages.length === 0) return []
+
+  const normalized = packages
+    .map(pkg => {
+      const trimmed = pkg.trim()
+      if (trimmed === '') return null
+      if (trimmed === '.' || trimmed === './') return ''
+
+      return trimmed.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, '')
+    })
+    .filter((value): value is string => value !== null)
+
+  return Array.from(new Set(normalized))
+}
+
+function matchesPackage(detection: BuildToolDetection, pkg: string): boolean {
+  const configPath = detection.configPath.replace(/\\/g, '/')
+  if (!pkg) {
+    return !configPath.includes('/')
+  }
+
+  return configPath === pkg || configPath.startsWith(`${pkg}/`)
+}
+
+function matchesAnyPackage(detection: BuildToolDetection, packages: string[]): boolean {
+  if (packages.length === 0) return true
+  return packages.some(pkg => matchesPackage(detection, pkg))
+}

package/src/detect/build-tool.ts

@@ -5,6 +5,7 @@
 // Recognized but unsupported: Next.js / Nuxt / Remix / Astro / SvelteKit
 // ============================================================
 import path from 'node:path'
+import { createRequire } from 'node:module'
 import { exists, readJSON } from '../utils/fs.js'
 import type { BuildTool, BuildToolDetection } from '../types.js'
 
@@ -12,13 +13,54 @@ interface PackageJSON {
   dependencies?: Record<string, string>
   devDependencies?: Record<string, string>
   scripts?: Record<string, string>
+  version?: string
+}
+
+/**
+ * Helper to check if a package can be resolved from the root directory.
+ * This handles monorepo hoisting and implicit dependencies.
+ */
+function isPackageResolvable(pkgName: string, root: string): boolean {
+  try {
+    const require = createRequire(path.join(root, 'package.json'))
+    try {
+      require.resolve(`${pkgName}/package.json`, { paths: [root] })
+      return true
+    } catch {
+      require.resolve(pkgName, { paths: [root] })
+      return true
+    }
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Attempts to read the actual version of a hoisted package from node_modules.
+ */
+async function getResolvedPackageVersion(pkgName: string, root: string): Promise<string | null> {
+  try {
+    const require = createRequire(path.join(root, 'package.json'))
+    const pkgJsonPath = require.resolve(`${pkgName}/package.json`, { paths: [root] })
+    const pkg = await readJSON<PackageJSON>(pkgJsonPath)
+    return pkg?.version || null
+  } catch {
+    return null
+  }
 }
 
 /** Supported build tools in v1 */
 const SUPPORTED_PATTERNS: { tool: BuildTool; files: string[]; label: string }[] = [
   {
     tool: 'vite',
-    files: ['vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs'],
+    files: [
+      'vite.config.ts',
+      'vite.config.js',
+      'vite.config.mts',
+      'vite.config.mjs',
+      'vite.config.cjs',
+      'vite.config.cts',
+    ],
     label: 'Vite',
   },
   {
@@ -57,126 +99,223 @@ const UNSUPPORTED_META: { name: string; dep: string; files: string[] }[] = [
   { name: 'SvelteKit', dep: '@sveltejs/kit', files: ['svelte.config.js', 'svelte.config.ts'] },
 ]
 
+interface DetectionTarget {
+  /** Relative path provided via --packages ('' for repo root) */
+  packagePath: string
+  /** Absolute path to run detection from */
+  absolutePath: string
+}
+
 export interface BuildToolResult {
   supported: BuildToolDetection[]
   unsupported: string[]
 }
 
+function normalizeRelativePath(root: string, filePath: string): string {
+  const relative = path.relative(root, filePath)
+  const normalized = relative.split(path.sep).join('/')
+  return normalized || path.basename(filePath)
+}
+
+function createTargets(root: string, packagePaths?: string[]): DetectionTarget[] {
+  if (!packagePaths || packagePaths.length === 0) {
+    return [{ packagePath: '', absolutePath: root }]
+  }
+
+  return packagePaths.map(pkg => ({
+    packagePath: pkg,
+    absolutePath: pkg ? path.join(root, pkg) : root,
+  }))
+}
+
 /**
  * Detect all build tools / meta-frameworks.
  * Returns supported tools and recognized-but-unsupported meta-frameworks.
  */
-export async function detectBuildTools(root: string): Promise<BuildToolResult> {
+export async function detectBuildTools(
+  root: string,
+  packagePaths?: string[],
+): Promise<BuildToolResult> {
   const supported: BuildToolDetection[] = []
-  const unsupported: string[] = []
-
-  // Detect supported build tools (by config file)
-  const pkg = await readJSON<PackageJSON>(path.join(root, 'package.json'))
-  const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies }
-
-  const supportedChecks = SUPPORTED_PATTERNS.map(async pattern => {
-    // 1. Check if the package.json has a dependency for this tool
-    const hasDep =
-      pattern.tool === 'rspack'
-        ? !!(allDeps['@rspack/cli'] || allDeps['@rspack/core'])
-        : pattern.tool === 'webpack'
-          ? !!(allDeps['webpack'] || allDeps['webpack-cli'])
-          : pattern.tool === 'rsbuild'
-            ? !!allDeps['@rsbuild/core']
-            : !!allDeps[pattern.tool]
-
-    // 2. Look for config files
-    let detectedFile = ''
-
-    // For esbuild, dependency is strictly required
-    if (pattern.tool === 'esbuild' && !hasDep) {
-      return null
-    }
+  const unsupported = new Set<string>()
+  const targets = createTargets(root, packagePaths)
 
-    for (const file of pattern.files) {
-      if (await exists(path.join(root, file))) {
-        detectedFile = file
-        break
-      }
-    }
+  for (const target of targets) {
+    const pkg = await readJSON<PackageJSON>(path.join(target.absolutePath, 'package.json'))
+    const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies }
+    const scripts = pkg?.scripts || {}
 
-    // 3. For esbuild and rollup, if they are in dependencies but no standard config is found,
-    // we still consider them detected (as they are often used with custom scripts)
-    if (hasDep && !detectedFile && (pattern.tool === 'esbuild' || pattern.tool === 'rollup')) {
-      // Look at npm scripts to guess the build file
-      const scripts = pkg?.scripts || {}
-      for (const [_, cmd] of Object.entries(scripts)) {
-        if (cmd.includes('node ')) {
-          const match = cmd.match(/node\s+([^\s]+\.(js|mjs|cjs|ts))/)
-          if (match && match[1]) {
-            if (await exists(path.join(root, match[1]))) {
-              detectedFile = match[1]
-              break
-            }
-          }
-        } else if (cmd.includes(`${pattern.tool} `)) {
-          detectedFile = 'package.json (scripts)'
-          break
-        }
+    const supportedChecks = SUPPORTED_PATTERNS.map(pattern =>
+      detectPattern({
+        pattern,
+        workspaceRoot: root,
+        targetRoot: target.absolutePath,
+        packagePath: target.packagePath,
+        allDeps,
+        scripts,
+      }),
+    )
+
+    const supportedResults = await Promise.all(supportedChecks)
+    for (const result of supportedResults) {
+      if (result) {
+        supported.push(result)
       }
     }
 
-    if (detectedFile) {
-      let isLegacyRspack = false
-      let isLegacyWebpack = false
-
-      if (pattern.tool === 'rspack') {
-        const version = allDeps['@rspack/cli'] || allDeps['@rspack/core']
-        if (
-          version &&
-          (version.includes('0.3.') || version.includes('0.2.') || version.includes('0.1.'))
-        ) {
-          isLegacyRspack = true
-        }
-      } else if (pattern.tool === 'webpack') {
-        const version = allDeps['webpack'] || allDeps['webpack-cli']
-        if ((version && version.includes('^4')) || version?.startsWith('4.')) {
-          isLegacyWebpack = true
+    const unsupportedChecks = UNSUPPORTED_META.map(async meta => {
+      if (!(meta.dep in allDeps)) return null
+      for (const file of meta.files) {
+        if (await exists(path.join(target.absolutePath, file))) {
+          return meta.name
         }
       }
+      return null
+    })
 
-      return {
-        tool: pattern.tool,
-        configPath: detectedFile,
-        label: `${pattern.label} (${detectedFile})${isLegacyRspack ? ' [Legacy]' : ''}${isLegacyWebpack ? ' [Webpack 4]' : ''}`,
-        isLegacyRspack,
-        isLegacyWebpack,
+    const unsupportedResults = await Promise.all(unsupportedChecks)
+    for (const result of unsupportedResults) {
+      if (result) {
+        unsupported.add(result)
       }
     }
+  }
+
+  return { supported, unsupported: Array.from(unsupported) }
+}
+
+interface PatternContext {
+  pattern: { tool: BuildTool; files: string[]; label: string }
+  workspaceRoot: string
+  targetRoot: string
+  packagePath: string
+  allDeps: Record<string, string | undefined>
+  scripts: Record<string, string>
+}
+
+async function detectPattern({
+  pattern,
+  workspaceRoot,
+  targetRoot,
+  packagePath,
+  allDeps,
+  scripts,
+}: PatternContext): Promise<BuildToolDetection | null> {
+  let hasDep: boolean
+  let resolvedVersion: string | null = null
+
+  if (pattern.tool === 'rspack') {
+    const depName = allDeps['@rspack/cli'] ? '@rspack/cli' : '@rspack/core'
+    hasDep =
+      !!allDeps['@rspack/cli'] ||
+      !!allDeps['@rspack/core'] ||
+      isPackageResolvable('@rspack/core', targetRoot)
+
+    if (hasDep) {
+      resolvedVersion =
+        allDeps[depName] || (await getResolvedPackageVersion('@rspack/core', targetRoot))
+    }
+  } else if (pattern.tool === 'webpack') {
+    const depName = allDeps['webpack'] ? 'webpack' : 'webpack-cli'
+    hasDep =
+      !!allDeps['webpack'] || !!allDeps['webpack-cli'] || isPackageResolvable('webpack', targetRoot)
 
+    if (hasDep) {
+      resolvedVersion = allDeps[depName] || (await getResolvedPackageVersion('webpack', targetRoot))
+    }
+  } else if (pattern.tool === 'rsbuild') {
+    hasDep = !!allDeps['@rsbuild/core'] || isPackageResolvable('@rsbuild/core', targetRoot)
+  } else {
+    hasDep = !!allDeps[pattern.tool] || isPackageResolvable(pattern.tool, targetRoot)
+  }
+
+  let detectedFile = ''
+
+  if (pattern.tool === 'esbuild' && !hasDep) {
     return null
-  })
+  }
 
-  const supportedResults = await Promise.all(supportedChecks)
-  for (const result of supportedResults) {
-    if (result) {
-      supported.push(result)
+  for (const file of pattern.files) {
+    if (await exists(path.join(targetRoot, file))) {
+      detectedFile = file
+      break
     }
   }
 
-  const unsupportedChecks = UNSUPPORTED_META.map(async meta => {
-    if (!(meta.dep in allDeps)) return null
-    for (const file of meta.files) {
-      if (await exists(path.join(root, file))) {
-        return meta.name
+  if (
+    hasDep &&
+    !detectedFile &&
+    (pattern.tool === 'esbuild' ||
+      pattern.tool === 'rollup' ||
+      pattern.tool === 'webpack' ||
+      pattern.tool === 'rspack' ||
+      pattern.tool === 'rsbuild')
+  ) {
+    for (const cmd of Object.values(scripts)) {
+      if (cmd.includes('node ')) {
+        const match = cmd.match(/node\s+([^\s]+\.(js|mjs|cjs|ts))/)
+        if (match && match[1]) {
+          if (await exists(path.join(targetRoot, match[1]))) {
+            if (cmd.includes(pattern.tool) || match[1].includes(pattern.tool)) {
+              detectedFile = match[1]
+              break
+            }
+          }
+        }
+      } else if (cmd.includes(`${pattern.tool} `)) {
+        if (pattern.tool === 'webpack' || pattern.tool === 'rspack') {
+          const configMatch = cmd.match(/--config\s+([^\s]+)/)
+          if (configMatch && configMatch[1]) {
+            if (await exists(path.join(targetRoot, configMatch[1]))) {
+              detectedFile = configMatch[1]
+              break
+            }
+          }
+        }
+
+        if (!detectedFile) {
+          detectedFile = 'package.json (scripts)'
+          break
+        }
       }
     }
+  }
+
+  if (!detectedFile) {
     return null
-  })
+  }
 
-  const unsupportedResults = await Promise.all(unsupportedChecks)
-  for (const result of unsupportedResults) {
-    if (result) {
-      unsupported.push(result)
+  let isLegacyRspack = false
+  let isLegacyWebpack = false
+
+  if (pattern.tool === 'rspack') {
+    const version = resolvedVersion
+    if (
+      version &&
+      (version.includes('0.3.') || version.includes('0.2.') || version.includes('0.1.'))
+    ) {
+      isLegacyRspack = true
+    }
+  } else if (pattern.tool === 'webpack') {
+    const version = resolvedVersion
+    if ((version && version.includes('^4')) || version?.startsWith('4.')) {
+      isLegacyWebpack = true
     }
   }
 
-  return { supported, unsupported }
+  const absoluteConfig = path.join(targetRoot, detectedFile)
+  const relativeConfig = normalizeRelativePath(workspaceRoot, absoluteConfig)
+
+  return {
+    tool: pattern.tool,
+    configPath: relativeConfig,
+    label: `${pattern.label} (${relativeConfig})${isLegacyRspack ? ' [Legacy]' : ''}${
+      isLegacyWebpack ? ' [Webpack 4]' : ''
+    }`,
+    isLegacyRspack,
+    isLegacyWebpack,
+    packagePath: packagePath || undefined,
+  }
 }
 
 /**

package/src/detect/framework.ts

@@ -5,6 +5,7 @@
 // Recognized but unsupported: Solid, Svelte, Angular, Preact, Lit
 // ============================================================
 import path from 'node:path'
+import { createRequire } from 'node:module'
 import { readJSON } from '../utils/fs.js'
 
 export type Framework = 'react' | 'vue'
@@ -17,6 +18,20 @@ export interface FrameworkDetection {
 interface PackageJSON {
   dependencies?: Record<string, string>
   devDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+}
+
+// Map meta-frameworks to their underlying UI frameworks
+const META_FRAMEWORK_MAP: Record<string, Framework> = {
+  next: 'react',
+  nuxt: 'vue',
+  '@remix-run/react': 'react',
+  '@remix-run/dev': 'react',
+  '@vue/nuxt': 'vue',
+  'vite-plugin-vue': 'vue',
+  '@vitejs/plugin-vue': 'vue',
+  '@vitejs/plugin-react': 'react',
+  '@vitejs/plugin-react-swc': 'react',
 }
 
 /** Supported frameworks in v1 */
@@ -34,32 +49,79 @@ const UNSUPPORTED_FRAMEWORKS: { name: string; dep: string }[] = [
   { name: 'Lit', dep: 'lit' },
 ]
 
+/**
+ * Helper to check if a package can be resolved from the root directory.
+ * This handles monorepo hoisting and implicit dependencies.
+ */
+function isPackageResolvable(pkgName: string, root: string): boolean {
+  try {
+    const require = createRequire(path.join(root, 'package.json'))
+    // Some packages might not expose package.json in exports, so resolving the package name directly is safer for entry points,
+    // but resolving package.json is generally safer to just check existence without executing code.
+    // We'll try resolving package.json first, and fallback to resolving the package root if possible.
+    try {
+      require.resolve(`${pkgName}/package.json`, { paths: [root] })
+      return true
+    } catch {
+      require.resolve(pkgName, { paths: [root] })
+      return true
+    }
+  } catch {
+    return false
+  }
+}
+
 /**
  * Detect frontend frameworks.
+ * Uses a waterfall approach:
+ * 1. Checks package.json explicitly (dependencies, devDependencies, peerDependencies)
+ * 2. Checks meta-frameworks mapping (e.g. nuxt -> vue)
+ * 3. Uses Node.js module resolution to find hoisted/implicit packages
  * Returns both supported and recognized-but-unsupported frameworks.
  */
 export async function detectFrameworks(root: string): Promise<FrameworkDetection> {
   const pkg = await readJSON<PackageJSON>(path.join(root, 'package.json'))
-  if (!pkg) return { supported: [], unsupported: [] }
 
   const allDeps = {
-    ...pkg.dependencies,
-    ...pkg.devDependencies,
+    ...(pkg?.dependencies || {}),
+    ...(pkg?.devDependencies || {}),
+    ...(pkg?.peerDependencies || {}),
   }
 
-  const supported: Framework[] = []
+  const supportedSet = new Set<Framework>()
+  const unsupported: { name: string; dep: string }[] = []
+
+  // Skip node resolution mock errors during unit tests
+  const isTest = root.includes('/mock/root')
+
+  // Tier 1: Meta-framework / Ecosystem Inference
+  for (const [metaPkg, framework] of Object.entries(META_FRAMEWORK_MAP)) {
+    if (metaPkg in allDeps || (!isTest && isPackageResolvable(metaPkg, root))) {
+      supportedSet.add(framework)
+    }
+  }
+
+  // Tier 2: Explicit Dependency & Node Resolution (Hoisting support)
   for (const { framework, deps } of SUPPORTED_FRAMEWORKS) {
-    if (deps.some(dep => dep in allDeps)) {
-      supported.push(framework)
+    if (supportedSet.has(framework)) continue
+
+    for (const dep of deps) {
+      if (dep in allDeps || (!isTest && isPackageResolvable(dep, root))) {
+        supportedSet.add(framework)
+        break
+      }
     }
   }
 
-  const unsupported: { name: string; dep: string }[] = []
+  // Tier 3: Check unsupported frameworks
   for (const fw of UNSUPPORTED_FRAMEWORKS) {
-    if (fw.dep in allDeps) {
+    if (fw.dep in allDeps || (!isTest && isPackageResolvable(fw.dep, root))) {
       unsupported.push(fw)
     }
   }
 
-  return { supported, unsupported }
+  return {
+    supported: Array.from(supportedSet),
+    unsupported,
+  }
 }