@grafana/create-plugin 7.16.0 → 7.18.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [7.18.0](https://github.com/grafana/plugin-tools/compare/@grafana/create-plugin@7.17.0...@grafana/create-plugin@7.18.0) (2026-11-02)
+
+
+### Features
+
+* add AI-agent assisted rspack addition ([#2912](https://github.com/grafana/plugin-tools/issues/2912)) ([250a2d3](https://github.com/grafana/plugin-tools/commit/250a2d362527b10f9aae0c3d7bd62003d2b17819))
+
+
+### Bug Fixes
+
+* **create-plugin:** bump deps in `add docs` codemod ([#3043](https://github.com/grafana/plugin-tools/issues/3043)) ([cee49b3](https://github.com/grafana/plugin-tools/commit/cee49b367aee2a0c0bd7b23531f8b9f938cbe398))
+
+## [7.17.0](https://github.com/grafana/plugin-tools/compare/@grafana/create-plugin@7.16.0...@grafana/create-plugin@7.17.0) (2026-10-28)
+
+
+### Features
+
+* remove dependency on glob ([#2655](https://github.com/grafana/plugin-tools/issues/2655)) ([9db0649](https://github.com/grafana/plugin-tools/commit/9db0649fd4dee9b5745a248ba421998cd9b86764))
+
+
+### Bug Fixes
+
+* **templates:** Update dependency @grafana/plugin-e2e to v3.15.2 ([#3022](https://github.com/grafana/plugin-tools/issues/3022)) ([2115b27](https://github.com/grafana/plugin-tools/commit/2115b27767554a555640300c7b4dc9c9e1842909))
+
 ## [7.16.0](https://github.com/grafana/plugin-tools/compare/@grafana/create-plugin@7.15.1...@grafana/create-plugin@7.16.0) (2026-10-22)
 
 

package/dist/codemods/additions/additions.js

@@ -10,6 +10,13 @@ const additions = [
     description: "Externalizes the react JSX runtime to help migrate plugins to React 19",
     scriptPath: import.meta.resolve("./scripts/externalize-jsx-runtime.js")
   },
+  {
+    name: "rspack",
+    description: "Migrates the plugin frontend build from webpack or experimental rspack to rspack 2",
+    scriptPath: import.meta.resolve("./scripts/rspack.js"),
+    prompt: import.meta.resolve("./prompts/rspack.md"),
+    verify: ["typecheck", "build"]
+  },
   {
     name: "experimental-app-sdk",
     description: "Adds grafana-app-sdk CUE kind code generation to an app plugin",

package/dist/codemods/additions/prompts/rspack.md

@@ -0,0 +1,118 @@
+# Migrate the plugin's custom build configuration to rspack
+
+## Context
+
+This plugin is moving its frontend build to rspack 2. The `create-plugin add rspack` codemod has already done the parts that create-plugin owns:
+
+- Rendered the rspack base config in `.config/rspack/` and the shared helpers in `.config/bundler/`, and set `useRspack` in `.config/.cprc.json`.
+- Deleted the create-plugin files in `.config/webpack/`. It kept any file there that the plugin added and listed it in its output.
+- Added the rspack packages (`@rspack/core`, `@rspack/cli`, `rspack-merge`, `diagnostics-webpack-plugin` and others) and removed webpack-only packages. It kept any webpack package that a root `webpack.*` or `rspack.*` file still imports and listed it.
+- Rewrote `webpack` commands in `package.json` scripts to `rspack`. It listed any script it could not rewrite.
+- If the plugin has a root `webpack.config.*`, added a root `rspack.config.ts` that throws an `[rspack]` error until the custom config is ported.
+- Raised `engines.node` to `>=22.23` if it allowed older versions.
+
+What is left is the plugin's own build customisation, which needs judgement to port. The previous base config is still in git: `git show HEAD:.config/webpack/webpack.config.ts`. Compare it with `.config/rspack/rspack.config.ts` when you need to know how a base rule or plugin changed.
+
+## Check first
+
+1. Install dependencies with the plugin's package manager, then run the `build` script. Keep the output; it is evidence, not a to-do list.
+2. Stop and report that nothing was needed if all of these are true:
+   - The build passes.
+   - There is no root `webpack.config.*` file.
+   - Root `rspack.config.ts`, if present, does not contain the `[rspack]` error.
+   - No script in `package.json` calls `webpack`.
+   - No plugin code builds a runtime URL to a file the new base config no longer copies into `dist` (see step 6).
+3. Otherwise, work out the starting point:
+   - **From webpack**: there is a root `webpack.config.*`, or `rspack.config.ts` contains the `[rspack]` error. Follow all the steps below.
+   - **From experimental rspack**: there is a root `rspack.config.ts` without the `[rspack]` error, and there is no root `webpack.config.*`. The config is already rspack but may use rspack 1 APIs. Skip step 2 and upgrade that file in place using steps 3 to 7.
+   - **No custom config**: there is neither a root `webpack.config.*` nor a root `rspack.config.ts`. Only step 6 applies.
+
+With a custom config, the build is expected to fail at this point with the `[rspack]` error. Do not chase build errors one by one; the steps below drive the work.
+
+## Steps
+
+1. Find every file that is part of the custom build: the root `webpack.config.*`, any file it imports (for example `webpack.config.utils.ts`), and any file the codemod reported as kept in `.config/webpack/`.
+
+2. Replace the body of root `rspack.config.ts` with a port of the root webpack config:
+   - Import the base config with `import grafanaConfig, { type Env } from './.config/rspack/rspack.config.ts';`.
+   - Merge with `rspack-merge` (`merge`, `mergeWithRules`, `mergeWithCustomize`, `unique`). It has the same API as `webpack-merge`, typed for rspack. Await the base config before merging.
+   - Keep the structure, comments and behaviour of the original. Port it; do not improve it.
+   - Remove the `[rspack]` error and the `TODO(rspack)` comment above it only when the port is complete.
+
+3. Replace webpack APIs and packages with their rspack equivalents. Import from `@rspack/core` with named imports, for example `import { DefinePlugin, NormalModuleReplacementPlugin } from '@rspack/core';`.
+
+   | webpack                                                                                                                                                                          | rspack                                                                                                                                                                                                                                            |
+   | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+   | `webpack` built-in plugins (`DefinePlugin`, `EnvironmentPlugin`, `BannerPlugin`, `ProvidePlugin`, `NormalModuleReplacementPlugin`, `ContextReplacementPlugin`) and `Compilation` | the same names from `@rspack/core`                                                                                                                                                                                                                |
+   | `webpack-merge`                                                                                                                                                                  | `rspack-merge`                                                                                                                                                                                                                                    |
+   | `copy-webpack-plugin`                                                                                                                                                            | `CopyRspackPlugin` from `@rspack/core`                                                                                                                                                                                                            |
+   | `swc-loader`, `babel-loader`                                                                                                                                                     | `builtin:swc-loader`                                                                                                                                                                                                                              |
+   | `fork-ts-checker-webpack-plugin`                                                                                                                                                 | `TsCheckerRspackPlugin` from `ts-checker-rspack-plugin`                                                                                                                                                                                           |
+   | `eslint-webpack-plugin`, `eslint-rspack-plugin`, or `diagnostics-webpack-plugin` used directly                                                                                   | `DiagnosticsRspackPlugin` from `./.config/rspack/DiagnosticsRspackPlugin.ts`, with `checks: [{ use: 'eslint', ... }]`. It wraps `diagnostics-webpack-plugin`, which fails under rspack on its own. `failOnError` and `severity` become `reportAs` |
+   | `webpack-livereload-plugin`                                                                                                                                                      | already in the base config for development builds                                                                                                                                                                                                 |
+   | `mini-css-extract-plugin`                                                                                                                                                        | `CssExtractRspackPlugin` from `@rspack/core`                                                                                                                                                                                                      |
+   | `css-minimizer-webpack-plugin`                                                                                                                                                   | `LightningCssMinimizerRspackPlugin` from `@rspack/core`                                                                                                                                                                                           |
+   | `terser-webpack-plugin` added by the plugin                                                                                                                                      | `SwcJsMinimizerRspackPlugin` from `@rspack/core`, or keep terser                                                                                                                                                                                  |
+   | `html-webpack-plugin`                                                                                                                                                            | `HtmlRspackPlugin` from `@rspack/core`                                                                                                                                                                                                            |
+   | `tsconfig-paths-webpack-plugin`                                                                                                                                                  | the `resolve.tsConfig` option                                                                                                                                                                                                                     |
+   | `file-loader`, `url-loader`, `raw-loader`                                                                                                                                        | asset modules: `type: 'asset/resource'`, `'asset/inline'`, `'asset/source'`                                                                                                                                                                       |
+   | plugins built on unplugin (`x/webpack`)                                                                                                                                          | the `x/rspack` entry point, where one exists                                                                                                                                                                                                      |
+   | imports from `.config/webpack/utils` or `.config/webpack/constants`                                                                                                              | `.config/bundler/utils.ts` and `.config/bundler/constants.ts`                                                                                                                                                                                     |
+
+   Check the [rspack migration guide](https://rspack.rs/guide/migration/webpack) for anything not listed here.
+
+4. Fix code that depends on how the base config is built. Each of these works in webpack and silently does nothing, or throws, in rspack:
+   - **Looking up a rule by loader name**, such as `rule.use.loader === 'swc-loader'`. The base config uses `builtin:swc-loader`, so match that. Prefer merging a rule over mutating the base one.
+   - **Looking up a plugin with `instanceof` or `constructor.name`** against webpack plugin classes, such as `CopyWebpackPlugin` or `LiveReloadPlugin`. Use the rspack class names, or merge instead of mutating.
+   - **`webpack-merge` rules keyed on old names**: `unique('plugins', ['CopyPlugin'], …)` or `mergeWithRules` matching `use.loader: 'swc-loader'`. Update the names.
+   - **A `filter` function on a `CopyWebpackPlugin` pattern**. `CopyRspackPlugin` has no `filter`; use `globOptions: { ignore: [...] }`. The base copy patterns come from `.config/bundler/copyFiles.ts`.
+   - **Removing the live reload plugin by filtering the plugins array**. The rspack base only adds it in development; filter on the rspack plugin class.
+   - **Native ESM loading**: the rspack CLI loads `rspack.config.ts` as native ESM. Replace `__dirname` with `import.meta.dirname`, `require.resolve(x)` with `createRequire(import.meta.url).resolve(x)`, and `require(x)` with `import`. Give relative imports explicit `.ts` extensions. `ReferenceError: __dirname is not defined` at build time means this step is not done.
+   - **rspack 2 defaults**: imports of exports that do not exist now fail the build (`exportsPresence: 'error'`). Fix the import in the plugin's code if it is clearly wrong; otherwise report it rather than changing the setting.
+   - **rspack 2 option moves**: `experiments.cache`, `experiments.incremental` and `experiments.lazyCompilation` are now top level. `experiments.css` is replaced by `module.rules[].type: 'css' | 'css/module' | 'css/auto'`. `experiments.outputModule` is `output.module`. `output.libraryTarget`, `libraryExport` and `umdNamedDefine` move under `output.library`. `SubresourceIntegrityPlugin` is no longer under `experiments`.
+   - **Persistent cache**: the base config has none. If the webpack config set `cache.type: 'filesystem'`, drop it unless the plugin clearly needs it.
+
+5. Check whether the config adds a second transpiler for the plugin's own code. A rule that runs `esbuild-loader`, `babel-loader` or `ts-loader` on `.ts`, `.tsx`, `.js` or `.jsx` files outside `node_modules` overlaps with the base `builtin:swc-loader` rule. Every matching rule applies, so each file is transpiled twice, and the build still passes, so nothing flags it.
+   - Do not port the extra rule as it is.
+   - If the base `builtin:swc-loader` settings cover what the rule did, leave the rule out of `rspack.config.ts` and remove its loader package once nothing else uses it.
+   - If the rule does something the base config does not, for example a different JSX runtime or decorator support, move that setting into the `builtin:swc-loader` rule (see step 4) and leave the extra rule out.
+   - If you cannot tell, keep the rule with a `TODO(rspack):` comment above it explaining that it duplicates the base transpiler.
+   - Either way, name the rule in your report.
+
+6. Check for files the old base config copied into `dist` that the new one does not. The old base copied every `img/**`, `**/*.svg`, `**/*.png`, `**/*.html`, `libs/**` and `static/**` file; compare `git show HEAD:.config/webpack/webpack.config.ts` with `.config/bundler/copyFiles.ts`. The new base copies only `plugin.json` and other JSON files, the README, CHANGELOG and LICENSE, `query_help.md`, and the logos and screenshots listed in `plugin.json`. Code that builds a URL to one of the other files at runtime, for example `public/plugins/<plugin-id>/img/…` or `` `${pluginPublicPath}/img/how-it-works.svg` ``, now gets a 404. The build still passes, so nothing flags it.
+   - Where the path is a literal, import the file and use the imported URL, for example `import howItWorks from '../img/how-it-works.svg';` and `src={howItWorks}`. rspack then hashes the file and resolves its public path, including when the plugin is served from a CDN.
+   - Check what an import returns before converting. If the config sends `.svg` imports to `@svgr/webpack` or another loader, the import is a React component, not a URL. Use that loader's URL form if it has one, such as a `?url` resource query, or copy the file instead.
+   - The base asset rules only cover `png`, `jpg`, `jpeg`, `gif`, `svg` and font files. For other types, such as `webp`, add an `asset/resource` rule in `rspack.config.ts`.
+   - Copy the file instead of importing it when the path is built at runtime, for example `` `${base}/img/${name}.svg` ``, or when something outside the bundle refers to it, such as the README, documentation or another plugin. Add a `CopyRspackPlugin` to `rspack.config.ts` for just those files, with a comment saying why they are copied. Do not copy whole folders to be safe: every copied file ends up in the plugin archive.
+
+7. If something has no rspack equivalent, for example a monkey-patch of webpack internals, a custom `RuntimeModule` plugin, or an SWC Wasm plugin whose ABI does not match rspack's built-in SWC:
+   - Port what you can.
+   - Comment out the rest, keeping the original code in the comment, so it does not run and the build does not fail.
+   - Put a `TODO(rspack):` comment above it that says what the code did, why it has no direct equivalent, and a suggested approach.
+   - Never drop it silently.
+
+8. Fix any script the codemod reported as not rewritten so it calls `rspack` with `./rspack.config.ts` or `./.config/rspack/rspack.config.ts`, keeping its other commands and flags. Remove the CLI flags rspack does not support: `--progress`, `--color`, `--bail`, `--output-pathinfo`.
+
+9. For each file the codemod kept in `.config/webpack/`, copy what is still needed to a folder outside `.config/` (for example `build/`), port it to rspack, and update the imports. Do not delete the originals; list them so the user can delete them.
+
+10. Remove the webpack packages the codemod kept, once nothing imports them. Keep `webpack` itself if anything still imports it.
+
+11. Delete the root `webpack.config.*` and its helper files once everything in them is ported or commented with `TODO(rspack):`.
+
+## Verify
+
+1. Install dependencies, then run the `typecheck` and `build` scripts. Both must pass, with any unportable code commented out.
+2. Check that `dist/` contains `module.js`, `plugin.json`, and every file that plugin code or `plugin.json` refers to by path at runtime. Imported images are hashed, so their names change.
+3. Run the `dev` script briefly and check that it compiles and keeps watching.
+4. Fix only breakage caused by this migration.
+
+## Report
+
+End with a list of every `TODO(rspack):` comment you added (file, line, one-line reason), every file the user should delete, any duplicate transpiler rule you removed or kept (step 5), every image reference you changed to an import or kept as a copy (step 6), and any `exportsPresence` errors you left for the user.
+
+## Out of scope
+
+- Do not modify anything under `.config/`. It is managed by create-plugin and is overwritten by `create-plugin update`.
+- Do not change the plugin id or type in `src/plugin.json`.
+- Do not upgrade unrelated dependencies, and do not reformat files you did not change.
+- Do not refactor plugin source code, unless the build fails because of the bundler change or step 6 needs an image import.

package/dist/codemods/additions/scripts/docs.js

@@ -35,7 +35,7 @@ const schema = v.object({
     )
   )
 });
-const PLUGIN_DOCS_CLI_VERSION = "^0.8.0";
+const PLUGIN_DOCS_CLI_VERSION = "^0.13.0";
 const SUPPORTED_PLUGIN_TYPES = ["panel", "datasource", "app"];
 function docs(context, options) {
   const pluginType = assertSupportedPluginType(context);
@@ -465,7 +465,7 @@ const LOCK_FILES = {
 const RELEASE_WORKFLOW_PATH = ".github/workflows/release.yml";
 const REQUIRED_ACTION_REFS = {
   "grafana/plugin-actions/build-plugin": "build-plugin/v1.2.0",
-  "grafana/plugin-actions/package-plugin": "package-plugin/v1.3.3"
+  "grafana/plugin-actions/package-plugin": "package-plugin/v1.3.6"
 };
 const DOCS_SCRIPTS = {
   "docs:serve": "plugin-docs-cli serve --port 3001 --reload",

package/dist/codemods/additions/scripts/rspack.js

@@ -0,0 +1,322 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { validRange, minVersion, lt, major } from 'semver';
+import { replaceExperimentalRspackFlag } from '../../utils.rspack.js';
+import { renderHandlebarsTemplate } from '../../../utils/utils.handlebars.js';
+import { getTemplateData } from '../../../utils/utils.templates.js';
+import { renderTemplate, additionsDebug, addDependenciesToPackageJson, removeDependenciesFromPackageJson, readJsonFile } from '../../utils.js';
+
+const RSPACK_TEMPLATE_DATA_OVERRIDES = {
+  useRspack: true,
+  frontendBundler: "rspack"
+};
+const RSPACK_CONFIG_FILES = [
+  ".config/rspack/rspack.config.ts",
+  ".config/rspack/BuildModeRspackPlugin.ts",
+  ".config/rspack/LiveReloadRspackPlugin.ts",
+  ".config/rspack/LicenseRspackPlugin.ts",
+  ".config/rspack/DiagnosticsRspackPlugin.ts"
+];
+const RETIRED_RSPACK_FILES = [".config/rspack/liveReloadPlugin.ts"];
+const DOC_FILES = [".config/AGENTS/instructions.md", ".config/README.md"];
+const BUNDLER_FILES = [
+  ".config/bundler/constants.ts",
+  ".config/bundler/copyFiles.ts",
+  ".config/bundler/externals.ts",
+  ".config/bundler/utils.ts"
+];
+const WEBPACK_CONFIG_PATH = ".config/webpack/webpack.config.ts";
+const RSPACK_CONFIG_PATH = ".config/rspack/rspack.config.ts";
+const WEBPACK_TEMPLATE_FILES = [
+  ".config/webpack/BuildModeWebpackPlugin.ts",
+  ".config/webpack/PluginSchemaWebpackPlugin.ts",
+  ".config/webpack/constants.ts",
+  ".config/webpack/generateCode.ts",
+  ".config/webpack/publicPath.ts",
+  ".config/webpack/tsconfig.webpack.json",
+  ".config/webpack/utils.ts",
+  ".config/webpack/watchPluginJson.ts",
+  ".config/webpack/webpack.config.ts",
+  ".config/webpack/webpack.parts.ts"
+];
+function rspack(context) {
+  const hasWebpackSetup = context.doesFileExist(WEBPACK_CONFIG_PATH);
+  const hasRspackSetup = context.doesFileExist(RSPACK_CONFIG_PATH);
+  if (!hasWebpackSetup && !hasRspackSetup) {
+    context.setMessage({
+      level: "warning",
+      title: "No create-plugin bundler configuration found, so nothing was changed.",
+      body: [`The rspack addition expects ${WEBPACK_CONFIG_PATH} or ${RSPACK_CONFIG_PATH} to exist.`]
+    });
+    return context;
+  }
+  const followUps = [];
+  deleteRetiredRspackFiles(context);
+  renderTemplateFiles(context, RSPACK_CONFIG_FILES);
+  renderTemplateFiles(context, BUNDLER_FILES);
+  renderTemplateFiles(context, DOC_FILES, false);
+  replaceExperimentalRspackFlag(context, { enable: true });
+  followUps.push(...addRootRspackConfigStub(context));
+  followUps.push(...updatePackageJson(context));
+  followUps.push(...deleteWebpackTemplateFiles(context));
+  reportFollowUps(context, followUps);
+  return context;
+}
+function deleteRetiredRspackFiles(context) {
+  for (const filePath of RETIRED_RSPACK_FILES) {
+    if (context.doesFileExist(filePath)) {
+      context.deleteFile(filePath);
+    }
+  }
+}
+function reportFollowUps(context, followUps) {
+  if (followUps.length === 0) {
+    return;
+  }
+  context.setMessage({
+    level: "warning",
+    title: "The rspack addition left some things for you to review.",
+    body: followUps
+  });
+}
+const resolveTemplatePath = (relativePath) => fileURLToPath(new URL(`../../../../templates/common/${relativePath}`, import.meta.url));
+function renderTemplateFiles(context, filePaths, includeWarning = true) {
+  const templateData = { ...getTemplateData(), ...RSPACK_TEMPLATE_DATA_OVERRIDES };
+  for (const filePath of filePaths) {
+    const rendered = renderTemplate(resolveTemplatePath(filePath), includeWarning, templateData);
+    if (context.doesFileExist(filePath)) {
+      context.updateFile(filePath, rendered);
+    } else {
+      context.addFile(filePath, rendered);
+    }
+  }
+}
+const ROOT_CONFIG_EXTENSIONS = ["ts", "js", "cjs", "mjs", "cts", "mts"];
+function addRootRspackConfigStub(context) {
+  const rootWebpackConfig = ROOT_CONFIG_EXTENSIONS.map((extension) => `webpack.config.${extension}`).find(
+    (filePath) => context.doesFileExist(filePath)
+  );
+  if (!rootWebpackConfig) {
+    return [];
+  }
+  const existingRootRspackConfig = ROOT_CONFIG_EXTENSIONS.map((extension) => `rspack.config.${extension}`).find(
+    (filePath) => context.doesFileExist(filePath)
+  );
+  if (existingRootRspackConfig) {
+    return [
+      `${existingRootRspackConfig} already exists, so it was left as is. Check that it includes everything from ${rootWebpackConfig}.`
+    ];
+  }
+  additionsDebug(`Custom ${rootWebpackConfig} detected. Adding a rspack.config.ts stub that fails until it is ported.`);
+  context.addFile("rspack.config.ts", getRootRspackConfigStub(rootWebpackConfig));
+  return [
+    `rspack.config.ts was added and fails the build until the customisations in ${rootWebpackConfig} are ported to it.`
+  ];
+}
+function updatePackageJson(context) {
+  if (!context.doesFileExist("package.json")) {
+    additionsDebug("No package.json found. Skipping dependency and script updates.");
+    return [];
+  }
+  const followUps = [];
+  const templateVersions = getTemplateDevDependencyVersions();
+  const userBuildFileSources = readUserBuildFileSources(context);
+  const stillUsedDevDependencies = WEBPACK_ONLY_DEV_DEPENDENCIES.filter(
+    (name) => userBuildFileSources.some((source) => referencesPackage(source, name))
+  );
+  const unusedDevDependencies = WEBPACK_ONLY_DEV_DEPENDENCIES.filter(
+    (name) => !stillUsedDevDependencies.includes(name)
+  );
+  addDependenciesToPackageJson(
+    context,
+    {},
+    {
+      ...pickVersions(getMissingPackages(context, BASE_CONFIG_DEV_DEPENDENCIES), templateVersions),
+      ...pickVersions(RSPACK_DEV_DEPENDENCIES, templateVersions)
+    }
+  );
+  removeDependenciesFromPackageJson(context, [], unusedDevDependencies);
+  if (stillUsedDevDependencies.length > 0) {
+    followUps.push(
+      "These webpack packages were kept because your root build config still uses them. Remove them once the config is ported to rspack:",
+      ...stillUsedDevDependencies.map((name) => `  ${name}`)
+    );
+  }
+  const packageJson = readJsonFile(context, "package.json");
+  const { scripts, unparsedScripts } = rewriteWebpackScripts(packageJson.scripts ?? {});
+  if (packageJson.scripts) {
+    context.updateFile("package.json", JSON.stringify({ ...packageJson, scripts }, null, 2));
+  }
+  raiseNodeEngine(context);
+  dropLockedRspackOnePackages(context);
+  if (unparsedScripts.length > 0) {
+    followUps.push(
+      "These scripts still call webpack in a way the addition could not rewrite. Change them to call rspack with ./rspack.config.ts or ./.config/rspack/rspack.config.ts:",
+      ...unparsedScripts.map(([name, command]) => `  ${name}: ${command}`)
+    );
+  }
+  return followUps;
+}
+const MIN_NODE_VERSION = "22.23.0";
+function raiseNodeEngine(context) {
+  const packageJson = readJsonFile(context, "package.json");
+  const nodeRange = packageJson.engines?.node;
+  if (!nodeRange || !validRange(nodeRange)) {
+    return;
+  }
+  const lowestAllowedVersion = minVersion(nodeRange);
+  if (!lowestAllowedVersion || !lt(lowestAllowedVersion, MIN_NODE_VERSION)) {
+    return;
+  }
+  const engines = { ...packageJson.engines, node: ">=22.23" };
+  context.updateFile("package.json", JSON.stringify({ ...packageJson, engines }, null, 2));
+}
+const LOCKED_RSPACK_PACKAGE_PATTERN = /(^|\/)node_modules\/@rspack\//;
+function dropLockedRspackOnePackages(context) {
+  if (!context.doesFileExist("package-lock.json")) {
+    return;
+  }
+  const lockfile = readJsonFile(context, "package-lock.json");
+  const lockedCoreVersion = lockfile.packages?.["node_modules/@rspack/core"]?.version;
+  if (!lockfile.packages || !lockedCoreVersion || major(lockedCoreVersion) >= 2) {
+    return;
+  }
+  const packages = Object.fromEntries(
+    Object.entries(lockfile.packages).filter(([path]) => !LOCKED_RSPACK_PACKAGE_PATTERN.test(path))
+  );
+  context.updateFile("package-lock.json", JSON.stringify({ ...lockfile, packages }, null, 2) + "\n");
+}
+const WEBPACK_COMMAND_PATTERN = /(?<=(?:^|&&|\|\||;|\|)\s*(?:\w+=\S*\s+)*(?:npx\s+)?)webpack(?:-cli)?(?=\s|$)/g;
+const ROOT_WEBPACK_CONFIG_ARG_PATTERN = /((?:^|\s)(?:-c|--config)(?:\s+|=))(?:\.\/)?webpack\.config\.[cm]?[jt]s(?=\s|$)/g;
+const TEMPLATE_WEBPACK_CONFIG_ARG_PATTERN = /((?:^|\s)(?:-c|--config)(?:\s+|=))(?:\.\/)?\.config\/webpack\/webpack\.config\.ts(?=\s|$)/g;
+const REMAINING_WEBPACK_PATTERN = /(?:^|[\s/])webpack(?:-cli)?(?:[\s/]|$)|\.config\/webpack\//;
+function rewriteWebpackScripts(scripts) {
+  const unparsedScripts = [];
+  const rewrittenScripts = Object.fromEntries(
+    Object.entries(scripts).map(([name, command]) => {
+      const rewritten = command.replace(WEBPACK_COMMAND_PATTERN, "rspack").replace(ROOT_WEBPACK_CONFIG_ARG_PATTERN, "$1./rspack.config.ts").replace(TEMPLATE_WEBPACK_CONFIG_ARG_PATTERN, "$1./.config/rspack/rspack.config.ts");
+      if (REMAINING_WEBPACK_PATTERN.test(rewritten)) {
+        unparsedScripts.push([name, command]);
+        return [name, command];
+      }
+      return [name, rewritten];
+    })
+  );
+  return { scripts: rewrittenScripts, unparsedScripts };
+}
+const USER_BUILD_FILE_PATTERN = /^(webpack|rspack)\.[\w.-]*\.[cm]?[jt]s$/;
+function readUserBuildFileSources(context) {
+  return context.readDir(".").filter((filePath) => USER_BUILD_FILE_PATTERN.test(filePath)).map((filePath) => context.getFile(filePath) ?? "");
+}
+function referencesPackage(source, packageName) {
+  const escapedName = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`['"\`]${escapedName}(/[^'"\`]*)?['"\`]`).test(source);
+}
+const RSPACK_DEV_DEPENDENCIES = [
+  "@rspack/cli",
+  "@rspack/core",
+  "@types/ws",
+  "diagnostics-webpack-plugin",
+  "rspack-merge",
+  "rspack-plugin-virtual-module",
+  "ts-checker-rspack-plugin",
+  // style-loader and imports-loader still need webpack, and diagnostics-webpack-plugin peers on webpack ^5.106
+  "webpack",
+  "ws"
+];
+const WEBPACK_ONLY_DEV_DEPENDENCIES = [
+  "copy-webpack-plugin",
+  "eslint-webpack-plugin",
+  "fork-ts-checker-webpack-plugin",
+  "swc-loader",
+  "terser-webpack-plugin",
+  "webpack-cli",
+  "webpack-livereload-plugin",
+  "webpack-subresource-integrity",
+  "webpack-virtual-modules"
+];
+const BASE_CONFIG_DEV_DEPENDENCIES = [
+  "@swc/helpers",
+  "css-loader",
+  "imports-loader",
+  "replace-in-file-webpack-plugin",
+  "sass",
+  "sass-loader",
+  "style-loader"
+];
+const PACKAGE_JSON_TEMPLATE_DATA = {
+  ...RSPACK_TEMPLATE_DATA_OVERRIDES,
+  pluginName: "plugin",
+  orgName: "org",
+  pluginType: "panel",
+  packageManagerName: "npm",
+  packageManagerVersion: "10.0.0",
+  scenesVersion: "*",
+  isAppType: false,
+  isNPM: true
+};
+function getTemplateDevDependencyVersions() {
+  const template = readFileSync(resolveTemplatePath("_package.json"), "utf-8");
+  const rendered = JSON.parse(
+    renderHandlebarsTemplate(template, PACKAGE_JSON_TEMPLATE_DATA)
+  );
+  return rendered.devDependencies ?? {};
+}
+function pickVersions(names, templateVersions) {
+  return Object.fromEntries(
+    names.map((name) => {
+      const version = templateVersions[name];
+      if (!version) {
+        throw new Error(`The package.json template has no version for ${name}, which the rspack addition installs.`);
+      }
+      return [name, version];
+    })
+  );
+}
+function getMissingPackages(context, names) {
+  const packageJson = readJsonFile(context, "package.json");
+  const installed = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  return names.filter((name) => !(name in installed));
+}
+function deleteWebpackTemplateFiles(context) {
+  for (const filePath of WEBPACK_TEMPLATE_FILES) {
+    if (context.doesFileExist(filePath)) {
+      context.deleteFile(filePath);
+    }
+  }
+  const leftoverFiles = context.readDir(".config/webpack");
+  if (leftoverFiles.length === 0) {
+    return [];
+  }
+  return [
+    "These files in .config/webpack were not created by create-plugin, so they were kept. Move anything you still need out of .config and port it to rspack:",
+    ...leftoverFiles.map((filePath) => `  ${filePath}`)
+  ];
+}
+function getRootRspackConfigStub(rootWebpackConfig) {
+  return `import type { Configuration } from '@rspack/core';
+import { merge } from 'rspack-merge';
+
+import grafanaConfig, { type Env } from './.config/rspack/rspack.config.ts';
+
+// TODO(rspack): port the customisations in ./${rootWebpackConfig} to this file, then delete it.
+// Run \`npx @grafana/create-plugin@latest add rspack --agent\` to have an AI agent do the port,
+// or follow https://grafana.com/developers/plugin-tools/how-to-guides/extend-configurations
+// This file is loaded as native ESM, so CommonJS globals are not available. Use import.meta.dirname,
+// createRequire(import.meta.url) and .ts extensions on relative imports.
+throw new Error(
+  '[rspack] ${rootWebpackConfig} has not been ported to rspack.config.ts yet. ' +
+    'Run \`npx @grafana/create-plugin@latest add rspack --agent\` or port it by hand, then remove this error.'
+);
+
+const config = async (env: Env): Promise<Configuration> => {
+  const baseConfig = await grafanaConfig(env);
+
+  return merge(baseConfig, {});
+};
+
+export default config;
+`;
+}
+
+export { BASE_CONFIG_DEV_DEPENDENCIES, RSPACK_DEV_DEPENDENCIES, WEBPACK_ONLY_DEV_DEPENDENCIES, rspack as default, getTemplateDevDependencyVersions };

package/dist/codemods/agentic/prompts.js

@@ -34,7 +34,7 @@ Before changing any file, print a short plan of what you intend to do so the use
 
 <scope_rules>
 Make only the changes the addition instructions require. Do not run package installs, builds, or tests unless the instructions ask for them. Run the repository formatter on files you touched if one is configured. Do not reformat files you did not change.
-When a check fails (typecheck, lint, build or tests), fix the cause. Never make it pass by suppressing it: no disable comments, skipped or deleted tests, loosened compiler or lint settings, or changed scripts. If you cannot fix the cause, leave it failing and say so in your summary.
+When a check fails (typecheck, lint, build or tests), fix the cause. Never hide a failure: no disable comments, skipped or deleted tests, loosened compiler or lint settings, or scripts changed to skip the check. If the addition instructions say how to set aside something that cannot be applied, such as commenting it out under a \`TODO(<addition-name>):\` marker, follow them. Otherwise leave the check failing and say so in your summary.
 </scope_rules>
 
 <handoff_contract>

package/dist/codemods/migrations/migrations.js

@@ -108,11 +108,23 @@ var defaultMigrations = [
     version: "7.13.0",
     description: "Replace eslint-webpack-plugin with diagnostics-webpack-plugin in the webpack config. eslint-webpack-plugin depends on micromatch, which pulls in the braces dependency flagged by vulnerability scanners.",
     scriptPath: import.meta.resolve("./scripts/018-replace-eslint-webpack-plugin.js")
+  },
+  {
+    name: "019-remove-glob-dependency",
+    version: "7.17.0",
+    description: "Replace the glob package with the Node.js built-in fs.glob in bundler utils.",
+    scriptPath: import.meta.resolve("./scripts/019-remove-glob-dependency.js")
+  },
+  {
+    name: "020-rename-rspack-feature-flag",
+    version: "7.18.0",
+    description: "Rename the useExperimentalRspack feature flag to useRspack in .config/.cprc.json, and remove it from the plugin .cprc.json.",
+    scriptPath: import.meta.resolve("./scripts/020-rename-rspack-feature-flag.js")
   }
   // Do not use LEGACY_UPDATE_CUTOFF_VERSION for new migrations. It is only used above to force migrations to run
   // for those written before the switch to updates as migrations.
   //
-  // New migrations never pick a version: copy the unreleased version line from ../AGENTS.md exactly.
+  // New migrations should never specify a version: copy the unreleased version line from ../AGENTS.md exactly.
   // Do not paste it into a comment in this file, as release-please rewrites every line that carries it.
 ];
 

package/dist/codemods/migrations/scripts/019-remove-glob-dependency.js

@@ -0,0 +1,93 @@
+import { parseAsTypescript, findImports, findNamedImport, findFunctionDeclaration, callsFunction, insertImports, createImport, printAST } from '../../utils.ast.js';
+import { removeDependenciesFromPackageJson, migrationsDebug } from '../../utils.js';
+
+const OLD_PACKAGE_NAME = "glob";
+const NEW_PACKAGE_NAME = "node:fs/promises";
+const UTILS_PATHS = [".config/webpack/utils.ts", ".config/bundler/utils.ts"];
+const GET_ENTRIES_SOURCE = `export async function getEntries() {
+  const plugins: string[][] = [];
+  for await (const pluginJson of glob('**/src/**/plugin.json')) {
+    const folder = path.dirname(pluginJson);
+    const modules: string[] = [];
+    for await (const module of glob(\`\${folder}/module.{ts,tsx,js,jsx}\`)) {
+      modules.push(path.resolve(module));
+    }
+    plugins.push(modules);
+  }
+
+  return plugins.reduce<Record<string, string>>((result, modules) => {
+    return modules.reduce((innerResult, module) => {
+      const pluginPath = path.dirname(module);
+      const pluginName = path.relative(process.cwd(), pluginPath).replace(/src\\/?/i, '');
+      const entryName = pluginName === '' ? 'module' : \`\${pluginName}/module\`;
+
+      innerResult[entryName] = module;
+      return innerResult;
+    }, result);
+  }, {});
+}`;
+function migrate(context) {
+  const updatedPaths = UTILS_PATHS.filter((filePath) => replaceGlobWithFsGlob(context, filePath));
+  if (updatedPaths.length === 0) {
+    return context;
+  }
+  const isStillUsed = UTILS_PATHS.some((filePath) => {
+    const source = context.getFile(filePath);
+    if (!source) {
+      return false;
+    }
+    const parsed = parseAsTypescript(source);
+    return !parsed.success || findImports(parsed.ast, OLD_PACKAGE_NAME).length > 0;
+  });
+  if (context.doesFileExist("package.json") && !isStillUsed) {
+    removeDependenciesFromPackageJson(context, [OLD_PACKAGE_NAME], [OLD_PACKAGE_NAME]);
+  }
+  return context;
+}
+function replaceGlobWithFsGlob(context, utilsPath) {
+  if (!context.doesFileExist(utilsPath)) {
+    return false;
+  }
+  const source = context.getFile(utilsPath);
+  if (!source || !source.includes(OLD_PACKAGE_NAME)) {
+    return false;
+  }
+  const parsed = parseAsTypescript(source);
+  if (!parsed.success) {
+    migrationsDebug(`Failed to parse ${utilsPath}. Error: ${parsed.error.message}`);
+    return false;
+  }
+  const globImport = findNamedImport(parsed.ast, OLD_PACKAGE_NAME, "glob");
+  if (!globImport) {
+    return false;
+  }
+  const getEntries = findFunctionDeclaration(parsed.ast, "getEntries");
+  if (!getEntries) {
+    return false;
+  }
+  if (!callsFunction(getEntries.body, "glob")) {
+    return false;
+  }
+  const { declaration, specifier } = globImport;
+  declaration.specifiers = (declaration.specifiers ?? []).filter((candidate) => candidate !== specifier);
+  if (declaration.specifiers.length === 0) {
+    parsed.ast.program.body.splice(parsed.ast.program.body.indexOf(declaration), 1);
+  }
+  insertImports(parsed.ast, [createImport({ named: [{ name: "glob" }] }, NEW_PACKAGE_NAME)]);
+  getEntries.body = getFunctionBody(GET_ENTRIES_SOURCE);
+  context.updateFile(utilsPath, printAST(parsed.ast));
+  return true;
+}
+function getFunctionBody(source) {
+  const parsed = parseAsTypescript(source);
+  if (!parsed.success) {
+    throw parsed.error;
+  }
+  const [statement] = parsed.ast.program.body;
+  if (statement?.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "FunctionDeclaration") {
+    throw new Error("Failed to parse target function body");
+  }
+  return statement.declaration.body;
+}
+
+export { migrate as default };

package/dist/codemods/migrations/scripts/020-rename-rspack-feature-flag.js

@@ -0,0 +1,8 @@
+import { replaceExperimentalRspackFlag } from '../../utils.rspack.js';
+
+function migrate(context) {
+  replaceExperimentalRspackFlag(context, { enable: false });
+  return context;
+}
+
+export { migrate as default };