shakapacker 9.0.0 → 9.2.0

data/package/configExporter/configDocs.ts

@@ -0,0 +1,102 @@
+/**
+ * Documentation mapping for webpack/rspack configuration keys.
+ * Used to add inline comments when exporting configs with --annotate flag.
+ */
+
+export const CONFIG_DOCS: Record<string, string> = {
+  mode: "Controls webpack optimization: 'development' (fast builds, detailed errors), 'production' (optimized, minified), or 'none'",
+  output: "Configuration for output bundles",
+  "output.filename":
+    "Bundle name template. [name]=entry name, [contenthash]=content-based hash for caching, [chunkhash]=chunk hash",
+  "output.path": "Absolute directory path where bundles are written",
+  "output.publicPath":
+    "URL prefix for loading assets in the browser (used by webpack for code splitting and asset loading)",
+  "output.chunkFilename":
+    "Template for non-entry chunk files created by code splitting",
+  "output.assetModuleFilename":
+    "Template for asset module filenames (images, fonts, etc.)",
+  "output.crossOriginLoading":
+    "Cross-origin loading setting for script tags: 'anonymous', 'use-credentials', or false",
+  "output.globalObject":
+    "Global object reference for UMD builds (e.g., 'this', 'window', 'global')",
+  devtool:
+    "Source map style: 'source-map' (full, slow), 'eval-source-map' (full, fast rebuild), 'cheap-source-map' (fast, less detail), false (none)",
+  optimization: "Code optimization settings",
+  "optimization.minimize":
+    "Enable/disable minification (true in production mode)",
+  "optimization.minimizer":
+    "Array of minimizer plugins (e.g., TerserPlugin, CssMinimizerPlugin)",
+  "optimization.splitChunks":
+    "Code splitting configuration - extracts common dependencies into separate chunks",
+  "optimization.runtimeChunk":
+    "Extract webpack runtime into separate chunk: 'single' (one runtime for all), true (one per entry), false (inline)",
+  "optimization.moduleIds":
+    "Module ID generation strategy: 'deterministic' (stable), 'named' (readable), 'natural' (numeric order)",
+  "optimization.chunkIds":
+    "Chunk ID generation strategy: 'deterministic', 'named', 'natural'",
+  module: "Configures how different file types are processed",
+  "module.rules":
+    "Array of rules defining loaders and processing for different file types",
+  plugins:
+    "Array of webpack plugins to apply (e.g., HtmlWebpackPlugin, MiniCssExtractPlugin)",
+  resolve: "Module resolution configuration",
+  "resolve.extensions":
+    "File extensions to try when resolving modules (e.g., ['.js', '.jsx', '.ts', '.tsx'])",
+  "resolve.modules":
+    "Directories to search when resolving modules (e.g., ['node_modules', 'app/javascript'])",
+  "resolve.alias":
+    "Create import aliases for modules (e.g., @components -> ./src/components)",
+  resolveLoader: "Configuration for resolving loaders",
+  "resolveLoader.modules": "Directories to search for loaders",
+  entry:
+    "Entry points for the application - where webpack starts building the dependency graph",
+  devServer: "Webpack dev server configuration (HMR, proxying, HTTPS, etc.)",
+  "devServer.port": "Port number for dev server (default: 8080)",
+  "devServer.host": "Host for dev server (e.g., 'localhost', '0.0.0.0')",
+  "devServer.hot": "Enable Hot Module Replacement (HMR)",
+  "devServer.https": "Enable HTTPS for dev server",
+  stats:
+    "Controls bundle information display: 'normal', 'verbose', 'minimal', 'errors-only', 'none'",
+  bail: "Fail the build on first error (true) or continue and report all errors (false)",
+  performance: "Performance budget configuration",
+  "performance.maxAssetSize":
+    "Maximum size (in bytes) for individual assets before webpack warns",
+  "performance.maxEntrypointSize":
+    "Maximum size (in bytes) for entry point bundles before webpack warns",
+  target:
+    "Build target environment: 'web' (browser), 'node' (Node.js), 'webworker', etc.",
+  externals:
+    "Dependencies to exclude from bundle (assumed to be available in runtime environment)",
+  cache:
+    "Build caching configuration: false (disabled), { type: 'memory' }, or { type: 'filesystem' }",
+  watch: "Enable watch mode - rebuild on file changes",
+  watchOptions: "Watch mode configuration (polling, ignored files, etc.)"
+}
+
+/**
+ * Get documentation for a specific config key path.
+ * Supports nested paths like 'output.filename'.
+ */
+export function getDocForKey(keyPath: string): string | undefined {
+  return CONFIG_DOCS[keyPath]
+}
+
+/**
+ * Get documentation for a key, trying parent paths if exact match not found.
+ * E.g., 'output.filename' -> tries 'output.filename', then 'output'
+ */
+export function getDocForKeyWithFallback(keyPath: string): string | undefined {
+  // Try exact match first
+  if (CONFIG_DOCS[keyPath]) {
+    return CONFIG_DOCS[keyPath]
+  }
+
+  // Try parent key
+  const parts = keyPath.split(".")
+  if (parts.length > 1) {
+    const parentKey = parts.slice(0, -1).join(".")
+    return CONFIG_DOCS[parentKey]
+  }
+
+  return undefined
+}

data/package/configExporter/fileWriter.ts

@@ -0,0 +1,92 @@
+import { writeFileSync, mkdirSync, existsSync } from "fs"
+import { resolve, dirname, relative, isAbsolute, basename } from "path"
+import { tmpdir } from "os"
+import { FileOutput } from "./types"
+
+/**
+ * Handles writing config exports to files.
+ * Supports single file output or multiple files (one per config).
+ */
+export class FileWriter {
+  /**
+   * Write multiple config files (one per config in array)
+   */
+  writeMultipleFiles(outputs: FileOutput[], targetDir: string): void {
+    // Ensure directory exists
+    this.ensureDirectory(targetDir)
+
+    // Write each file
+    outputs.forEach((output) => {
+      const safeName = basename(output.filename)
+      const filePath = resolve(targetDir, safeName)
+      this.validateOutputPath(filePath)
+      this.writeFile(filePath, output.content)
+      console.log(`[Config Exporter] Created: ${filePath}`)
+    })
+
+    console.log(
+      `[Config Exporter] Exported ${outputs.length} config file(s) to ${targetDir}`
+    )
+  }
+
+  /**
+   * Write a single file
+   */
+  writeSingleFile(filePath: string, content: string, quiet = false): void {
+    // Ensure parent directory exists
+    const dir = dirname(filePath)
+    this.ensureDirectory(dir)
+
+    this.validateOutputPath(filePath)
+    this.writeFile(filePath, content)
+    if (!quiet && process.env.VERBOSE) {
+      console.log(`[Config Exporter] Config exported to: ${filePath}`)
+    }
+  }
+
+  /**
+   * Generate filename for a config export
+   * Format: {bundler}-{env}-{type}.{ext}
+   * Examples:
+   *   webpack-development-client.yaml
+   *   rspack-production-server.yaml
+   *   webpack-test-all.json
+   */
+  generateFilename(
+    bundler: string,
+    env: string,
+    configType: "client" | "server" | "all",
+    format: "yaml" | "json" | "inspect"
+  ): string {
+    const ext = format === "yaml" ? "yaml" : format === "json" ? "json" : "txt"
+    return `${bundler}-${env}-${configType}.${ext}`
+  }
+
+  private writeFile(filePath: string, content: string): void {
+    writeFileSync(filePath, content, "utf8")
+  }
+
+  private ensureDirectory(dir: string): void {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true })
+    }
+  }
+
+  /**
+   * Validate output path and warn if writing outside cwd
+   */
+  validateOutputPath(outputPath: string): void {
+    const absPath = resolve(outputPath)
+    const cwd = process.cwd()
+
+    const isWithin = (base: string, target: string) => {
+      const rel = relative(base, target)
+      return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel))
+    }
+    if (!isWithin(cwd, absPath) && !isWithin(tmpdir(), absPath)) {
+      console.warn(
+        `[Config Exporter] Warning: Writing to ${absPath} which is outside current directory (${cwd}) or temp (${tmpdir()})`
+      )
+    }
+  }
+}

data/package/configExporter/index.ts

@@ -0,0 +1,5 @@
+export { run } from "./cli"
+export type { ExportOptions, ConfigMetadata, FileOutput } from "./types"
+export { YamlSerializer } from "./yamlSerializer"
+export { FileWriter } from "./fileWriter"
+export { getDocForKey } from "./configDocs"

data/package/configExporter/types.ts

@@ -0,0 +1,36 @@
+export interface ExportOptions {
+  doctor?: boolean
+  save?: boolean
+  saveDir?: string
+  bundler?: "webpack" | "rspack"
+  env?: "development" | "production" | "test"
+  clientOnly?: boolean
+  serverOnly?: boolean
+  output?: string
+  format?: "yaml" | "json" | "inspect"
+  annotate?: boolean
+  verbose?: boolean
+  depth?: number | null
+  help?: boolean
+}
+
+export interface ConfigMetadata {
+  exportedAt: string
+  bundler: string
+  environment: string
+  configFile: string
+  configType: "client" | "server" | "all"
+  configCount: number
+  environmentVariables: {
+    NODE_ENV?: string
+    RAILS_ENV?: string
+    CLIENT_BUNDLE_ONLY?: string
+    SERVER_BUNDLE_ONLY?: string
+  }
+}
+
+export interface FileOutput {
+  filename: string
+  content: string
+  metadata: ConfigMetadata
+}

data/package/configExporter/yamlSerializer.ts

@@ -0,0 +1,266 @@
+import { ConfigMetadata } from "./types"
+import { getDocForKey } from "./configDocs"
+import { relative, isAbsolute } from "path"
+
+/**
+ * Serializes webpack/rspack config to YAML format with optional inline documentation.
+ * Handles functions, RegExp, and special objects that don't serialize well to standard YAML.
+ */
+export class YamlSerializer {
+  private annotate: boolean
+  private appRoot: string
+
+  constructor(options: { annotate: boolean; appRoot: string }) {
+    this.annotate = options.annotate
+    this.appRoot = options.appRoot
+  }
+
+  /**
+   * Serialize a config object to YAML string with metadata header
+   */
+  serialize(config: any, metadata: ConfigMetadata): string {
+    const output: string[] = []
+
+    // Add metadata header
+    output.push(this.createHeader(metadata))
+    output.push("")
+
+    // Serialize the config
+    output.push(this.serializeValue(config, 0, ""))
+
+    return output.join("\n")
+  }
+
+  private createHeader(metadata: ConfigMetadata): string {
+    const lines: string[] = []
+    lines.push("# " + "=".repeat(77))
+    lines.push("# Webpack/Rspack Configuration Export")
+    lines.push(`# Generated: ${metadata.exportedAt}`)
+    lines.push(`# Environment: ${metadata.environment}`)
+    lines.push(`# Bundler: ${metadata.bundler}`)
+    lines.push(`# Config Type: ${metadata.configType}`)
+    if (metadata.configCount > 1) {
+      lines.push(`# Total Configs: ${metadata.configCount}`)
+    }
+    lines.push("# " + "=".repeat(77))
+    return lines.join("\n")
+  }
+
+  private serializeValue(value: any, indent: number, keyPath: string): string {
+    if (value === null || value === undefined) {
+      return "null"
+    }
+
+    if (typeof value === "boolean") {
+      return value.toString()
+    }
+
+    if (typeof value === "number") {
+      return value.toString()
+    }
+
+    if (typeof value === "string") {
+      return this.serializeString(value, indent)
+    }
+
+    if (typeof value === "function") {
+      return this.serializeFunction(value)
+    }
+
+    if (value instanceof RegExp) {
+      return this.serializeString(value.toString())
+    }
+
+    if (Array.isArray(value)) {
+      return this.serializeArray(value, indent, keyPath)
+    }
+
+    if (typeof value === "object") {
+      return this.serializeObject(value, indent, keyPath)
+    }
+
+    return String(value)
+  }
+
+  private serializeString(str: string, indent: number = 0): string {
+    // Make absolute paths relative for cleaner output
+    const cleaned = this.makePathRelative(str)
+
+    // Handle multiline strings
+    if (cleaned.includes("\n")) {
+      const lines = cleaned.split("\n")
+      const lineIndent = " ".repeat(indent + 2)
+      return "|\n" + lines.map((line) => lineIndent + line).join("\n")
+    }
+
+    // Escape strings that need quoting
+    if (
+      cleaned.includes(":") ||
+      cleaned.includes("#") ||
+      cleaned.includes("'") ||
+      cleaned.includes('"') ||
+      cleaned.startsWith(" ") ||
+      cleaned.endsWith(" ")
+    ) {
+      // Escape backslashes first, then quotes to avoid double-escaping
+      return `"${cleaned.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`
+    }
+
+    return cleaned
+  }
+
+  private serializeFunction(fn: Function): string {
+    // Get function source code
+    const source = fn.toString()
+
+    // Pretty-print function: maintain readable formatting
+    const lines = source.split("\n")
+
+    // For very long functions, truncate
+    const maxLines = 50
+    const truncated = lines.length > maxLines
+    const displayLines = truncated ? lines.slice(0, maxLines) : lines
+
+    // Clean up indentation while preserving structure
+    const minIndent = Math.min(
+      ...displayLines
+        .filter((l) => l.trim().length > 0)
+        .map((l) => l.match(/^\s*/)?.[0].length || 0)
+    )
+
+    const formatted =
+      displayLines.map((line) => line.substring(minIndent)).join("\n") +
+      (truncated ? "\n..." : "")
+
+    // Use serializeString to properly handle multiline
+    return this.serializeString(formatted)
+  }
+
+  private serializeArray(arr: any[], indent: number, keyPath: string): string {
+    if (arr.length === 0) {
+      return "[]"
+    }
+
+    const lines: string[] = []
+    const itemIndent = " ".repeat(indent + 2)
+    const contentIndent = " ".repeat(indent + 4)
+
+    arr.forEach((item, index) => {
+      const itemPath = `${keyPath}[${index}]`
+      const serialized = this.serializeValue(item, indent + 4, itemPath)
+
+      // Add documentation for array items if available
+      if (this.annotate) {
+        const doc = getDocForKey(itemPath)
+        if (doc) {
+          lines.push(`${itemIndent}# ${doc}`)
+        }
+      }
+
+      if (typeof item === "object" && !Array.isArray(item) && item !== null) {
+        // For objects in arrays, emit marker on its own line and indent content
+        lines.push(`${itemIndent}-`)
+        serialized
+          .split("\n")
+          .filter((line: string) => line.trim().length > 0)
+          .forEach((line: string) => {
+            lines.push(contentIndent + line)
+          })
+      } else if (serialized.includes("\n")) {
+        // For multiline values, emit marker on its own line and indent content
+        lines.push(`${itemIndent}-`)
+        serialized
+          .split("\n")
+          .filter((line: string) => line.trim().length > 0)
+          .forEach((line: string) => {
+            lines.push(contentIndent + line)
+          })
+      } else {
+        // For simple values, keep on same line
+        lines.push(`${itemIndent}- ${serialized}`)
+      }
+    })
+
+    return "\n" + lines.join("\n")
+  }
+
+  private serializeObject(obj: any, indent: number, keyPath: string): string {
+    const keys = Object.keys(obj)
+    if (keys.length === 0) {
+      return "{}"
+    }
+
+    const lines: string[] = []
+    const keyIndent = " ".repeat(indent)
+    const valueIndent = " ".repeat(indent + 2)
+
+    keys.forEach((key) => {
+      const value = obj[key]
+      const fullKeyPath = keyPath ? `${keyPath}.${key}` : key
+
+      // Add documentation comment if available and annotation is enabled
+      if (this.annotate) {
+        const doc = getDocForKey(fullKeyPath)
+        if (doc) {
+          lines.push(`${keyIndent}# ${doc}`)
+        }
+      }
+
+      // Handle multiline strings specially with block scalar
+      if (typeof value === "string" && value.includes("\n")) {
+        lines.push(`${keyIndent}${key}: |`)
+        for (const line of value.split("\n")) {
+          lines.push(`${valueIndent}${line}`)
+        }
+      } else if (
+        typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value)
+      ) {
+        if (Object.keys(value).length === 0) {
+          lines.push(`${keyIndent}${key}: {}`)
+        } else {
+          lines.push(`${keyIndent}${key}:`)
+          const nestedLines = this.serializeObject(
+            value,
+            indent + 2,
+            fullKeyPath
+          )
+          lines.push(nestedLines)
+        }
+      } else if (Array.isArray(value)) {
+        if (value.length === 0) {
+          lines.push(`${keyIndent}${key}: []`)
+        } else {
+          lines.push(`${keyIndent}${key}:`)
+          const arrayLines = this.serializeArray(value, indent + 2, fullKeyPath)
+          lines.push(arrayLines)
+        }
+      } else {
+        const serialized = this.serializeValue(value, indent + 2, fullKeyPath)
+        lines.push(`${keyIndent}${key}: ${serialized}`)
+      }
+    })
+
+    return lines.join("\n")
+  }
+
+  private makePathRelative(str: string): string {
+    if (typeof str !== "string") return str
+    if (!isAbsolute(str)) return str
+
+    // Convert absolute paths to relative paths using path.relative
+    const rel = relative(this.appRoot, str)
+
+    if (rel === "") {
+      return "."
+    }
+
+    // If path is outside appRoot or already absolute, keep original
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+      return str
+    }
+
+    return "./" + rel
+  }
+}

data/package/environments/__type-tests__/rspack-plugin-compatibility.ts

@@ -0,0 +1,30 @@
+/**
+ * Compile-time type tests for RspackPlugin backward compatibility
+ * This file ensures that RspackPlugin is correctly aliased to RspackPluginInstance
+ * and maintains backward compatibility for existing consumers.
+ *
+ * These tests will fail at compile time if the types are not compatible.
+ */
+
+import type { RspackPlugin, RspackPluginInstance } from '../types'
+
+// Test 1: RspackPlugin should be assignable to RspackPluginInstance
+const testPluginToInstance = (plugin: RspackPlugin): RspackPluginInstance => plugin
+
+// Test 2: RspackPluginInstance should be assignable to RspackPlugin
+const testInstanceToPlugin = (instance: RspackPluginInstance): RspackPlugin => instance
+
+// Test 3: Array compatibility
+const testArrayCompatibility = (plugins: RspackPlugin[]): RspackPluginInstance[] => plugins
+const testArrayCompatibilityReverse = (
+  instances: RspackPluginInstance[]
+): RspackPlugin[] => instances
+
+// Test 4: Optional parameter compatibility
+const testOptionalParam = (plugin?: RspackPlugin): RspackPluginInstance | undefined => plugin
+const testOptionalParamReverse = (
+  instance?: RspackPluginInstance
+): RspackPlugin | undefined => instance
+
+// Export a dummy value to make this a module
+export const __typeTestsComplete = true

data/package/environments/types.ts

@@ -3,8 +3,12 @@
  * These types are exported for consumer use
  */
 
-import type { Configuration as WebpackConfiguration, WebpackPluginInstance } from "webpack"
+import type {
+  Configuration as WebpackConfiguration,
+  WebpackPluginInstance
+} from "webpack"
 import type { Configuration as DevServerConfiguration } from "webpack-dev-server"
+import type { RspackPluginInstance as ImportedRspackPluginInstance } from "@rspack/core"
 
 /**
  * Webpack configuration extended with dev server support
@@ -15,15 +19,17 @@ export interface WebpackConfigWithDevServer extends WebpackConfiguration {
 }
 
 /**
- * Rspack plugin interface
- * Rspack plugins follow a similar pattern to webpack but may have different internals
+ * Rspack plugin instance interface
+ * Uses the RspackPluginInstance type from @rspack/core
  */
-export interface RspackPlugin {
-  new(...args: any[]): {
-    apply(compiler: any): void
-    [key: string]: any
-  }
-}
+export type RspackPluginInstance = ImportedRspackPluginInstance
+
+/**
+ * Rspack plugin type alias
+ * @deprecated Use RspackPluginInstance instead
+ * Retained for backward compatibility with existing code
+ */
+export type RspackPlugin = RspackPluginInstance
 
 /**
  * Rspack dev server configuration
@@ -52,7 +58,7 @@ export interface RspackConfigWithDevServer {
   mode?: "development" | "production" | "none"
   devtool?: string | false
   devServer?: RspackDevServerConfig
-  plugins?: RspackPlugin[]
+  plugins?: RspackPluginInstance[]
   module?: WebpackConfiguration["module"]
   resolve?: WebpackConfiguration["resolve"]
   entry?: WebpackConfiguration["entry"]
@@ -76,15 +82,17 @@ export interface CompressionPluginOptions {
 /**
  * Compression plugin constructor type
  */
-export type CompressionPluginConstructor = new (options: CompressionPluginOptions) => WebpackPluginInstance
+export type CompressionPluginConstructor = new (
+  options: CompressionPluginOptions
+) => WebpackPluginInstance
 
 /**
  * React Refresh plugin types
  */
 export interface ReactRefreshWebpackPlugin {
-  new(options?: Record<string, unknown>): WebpackPluginInstance
+  new (options?: Record<string, unknown>): WebpackPluginInstance
 }
 
 export interface ReactRefreshRspackPlugin {
-  new(options?: Record<string, unknown>): RspackPlugin
-}
+  new (options?: Record<string, unknown>): RspackPluginInstance
+}

data/package/index.ts

@@ -16,18 +16,21 @@ const inliningCss = require("./utils/inliningCss")
 const rulesPath = resolve(__dirname, "rules", `${config.assets_bundler}.js`)
 const rules = require(rulesPath)
 
-const generateWebpackConfig = (extraConfig: Configuration = {}, ...extraArgs: any[]): Configuration => {
+const generateWebpackConfig = (
+  extraConfig: Configuration = {},
+  ...extraArgs: unknown[]
+): Configuration => {
   if (extraArgs.length > 0) {
     throw new Error(
       `Invalid usage: generateWebpackConfig() accepts only one configuration object.\n\n` +
-      `You passed ${extraArgs.length + 1} arguments. Only one extra config may be passed here - use webpack-merge to merge configs before passing them to Shakapacker.\n\n` +
-      `Example:\n` +
-      `  const { merge } = require('webpack-merge')\n` +
-      `  const mergedConfig = merge(config1, config2, config3)\n` +
-      `  const finalConfig = generateWebpackConfig(mergedConfig)\n\n` +
-      `Or if using ES6:\n` +
-      `  import { merge } from 'webpack-merge'\n` +
-      `  const finalConfig = generateWebpackConfig(merge(config1, config2))`
+        `You passed ${extraArgs.length + 1} arguments. Only one extra config may be passed here - use webpack-merge to merge configs before passing them to Shakapacker.\n\n` +
+        `Example:\n` +
+        `  const { merge } = require('webpack-merge')\n` +
+        `  const mergedConfig = merge(config1, config2, config3)\n` +
+        `  const finalConfig = generateWebpackConfig(mergedConfig)\n\n` +
+        `Or if using ES6:\n` +
+        `  import { merge } from 'webpack-merge'\n` +
+        `  const finalConfig = generateWebpackConfig(merge(config1, config2))`
     )
   }
 

data/package/swc/index.ts

@@ -9,9 +9,11 @@ import type { RuleSetRule } from "webpack"
 const JSX_FILE_REGEX = /\.(jsx|tsx)(\.erb)?$/
 const TYPESCRIPT_FILE_REGEX = /\.(ts|tsx)(\.erb)?$/
 
-const isJsxFile = (filename: string): boolean => !!filename.match(JSX_FILE_REGEX)
+const isJsxFile = (filename: string): boolean =>
+  !!filename.match(JSX_FILE_REGEX)
 
-const isTypescriptFile = (filename: string): boolean => !!filename.match(TYPESCRIPT_FILE_REGEX)
+const isTypescriptFile = (filename: string): boolean =>
+  !!filename.match(TYPESCRIPT_FILE_REGEX)
 
 const getCustomConfig = (): Partial<RuleSetRule> => {
   const path = resolve("config", "swc.config.js")
@@ -37,7 +39,7 @@ const getSwcLoaderConfig = (filenameToProcess: string): RuleSetRule => {
           syntax: isTs ? "typescript" : "ecmascript",
           [jsxKey]: isJsx
         },
-        loose: true
+        loose: false
       },
       sourceMaps: true,
       env: {

data/package/types/README.md

@@ -41,7 +41,8 @@ import type {
 ### Webpack/Rspack Types
 - `WebpackConfigWithDevServer` - Webpack config with dev server
 - `RspackConfigWithDevServer` - Rspack config with dev server
-- `RspackPlugin` - Rspack plugin interface
+- `RspackPluginInstance` - Rspack plugin instance type
+- `RspackPlugin` - **⚠️ Deprecated:** Use `RspackPluginInstance` instead
 - `RspackDevServerConfig` - Rspack dev server configuration
 - `CompressionPluginOptions` - Options for compression plugin
 - `CompressionPluginConstructor` - Constructor type for compression plugin

data/package/types/index.ts

@@ -40,6 +40,7 @@ export type {
 // Environment configuration types
 export type {
   WebpackConfigWithDevServer,
+  RspackPluginInstance,
   RspackPlugin,
   RspackDevServerConfig,
   RspackConfigWithDevServer,