with-zephyr 0.0.0-canary.2 → 0.0.0-canary.20

package/README.md

@@ -34,13 +34,14 @@ bunx with-zephyr
 
 ## Supported Bundlers
 
-This codemod supports **11+ bundlers** with their respective Zephyr plugins:
+This codemod supports **12+ bundlers** with their respective Zephyr plugins:
 
 - **Webpack** ([`zephyr-webpack-plugin`](https://www.npmjs.com/package/zephyr-webpack-plugin))
 - **Rspack** ([`zephyr-rspack-plugin`](https://www.npmjs.com/package/zephyr-rspack-plugin))
 - **Vite** ([`vite-plugin-zephyr`](https://www.npmjs.com/package/vite-plugin-zephyr))
 - **Rollup** ([`rollup-plugin-zephyr`](https://www.npmjs.com/package/rollup-plugin-zephyr))
 - **Rolldown** ([`zephyr-rolldown-plugin`](https://www.npmjs.com/package/zephyr-rolldown-plugin))
+- **Astro** ([`zephyr-astro-integration`](https://www.npmjs.com/package/zephyr-astro-integration))
 - **Modern.js** ([`zephyr-modernjs-plugin`](https://www.npmjs.com/package/zephyr-modernjs-plugin))
 - **RSPress** ([`zephyr-rspress-plugin`](https://www.npmjs.com/package/zephyr-rspress-plugin))
 - **Parcel** ([`parcel-reporter-zephyr`](https://www.npmjs.com/package/parcel-reporter-zephyr))
@@ -92,9 +93,6 @@ This will:
 # Show what would be changed without modifying files
 npx with-zephyr --dry-run
 
-# Automatically install missing plugin packages
-npx with-zephyr --install
-
 # Specify a different directory
 npx with-zephyr ./my-project
 
@@ -102,10 +100,10 @@ npx with-zephyr ./my-project
 npx with-zephyr --bundlers webpack vite
 
 # Combine options
-npx with-zephyr ./src --dry-run --bundlers rollup --install
+npx with-zephyr ./src --dry-run --bundlers rollup
 
 # Use with other package managers
-pnpm dlx with-zephyr --install
+pnpm dlx with-zephyr
 yarn dlx with-zephyr --dry-run
 bunx with-zephyr --bundlers vite rollup
 ```
@@ -115,7 +113,8 @@ bunx with-zephyr --bundlers vite rollup
 - `[directory]` - Directory to search for config files (default: current directory)
 - `-d, --dry-run` - Show what would be changed without modifying files
 - `-b, --bundlers <bundlers...>` - Only process specific bundlers
-- `-i, --install` - Automatically install missing plugin packages
+
+> The codemod automatically installs missing Zephyr plugins using your detected package manager (npm/yarn/pnpm/bun). In `--dry-run` it will only list what would be installed.
 
 ## Examples
 
@@ -192,7 +191,7 @@ module.exports = (config) => {
 
 ## Package Management
 
-The codemod can automatically install missing Zephyr plugin packages using the `--install` flag.
+The codemod automatically installs missing Zephyr plugin packages when not running in `--dry-run` mode.
 
 ### Package Manager Detection
 
@@ -216,21 +215,10 @@ The tool automatically detects your package manager by checking for:
 - **pnpm**: `pnpm add --save-dev <package>`
 - **bun**: `bun add --dev <package>`
 
-### Usage with Package Installation
-
-```bash
-# Install packages and update configs in one command
-npx with-zephyr --install
+### Package Installation Behavior
 
-# Preview what packages would be installed
-npx with-zephyr --dry-run --install
-
-# The tool will show you which packages need to be installed if you don't use --install
-npx with-zephyr
-# Output: 💡 Tip: Use --install to automatically install missing packages:
-#           vite-plugin-zephyr
-#           zephyr-webpack-plugin
-```
+- `npx with-zephyr` will install any required Zephyr plugins that are missing.
+- `npx with-zephyr --dry-run` will list the packages it would install without making changes.
 
 ## Configuration File Detection
 
@@ -241,6 +229,7 @@ The codemod automatically detects and processes these configuration files:
 - `vite.config.js/ts/mjs`
 - `rollup.config.js/ts/mjs`
 - `rolldown.config.js/ts/mjs`
+- `astro.config.js/ts/mjs/mts`
 - `modern.config.js/ts/mjs`
 - `rspress.config.js/ts/mjs`
 - `rsbuild.config.js/ts/mjs`
@@ -304,7 +293,7 @@ Refer to the individual plugin documentation for specific setup instructions.
 
 ### Building
 
-The codemod is written in TypeScript and bundled with tsup:
+The codemod is written in TypeScript and built with Rspack/RSLib:
 
 ```bash
 # Install dependencies
@@ -318,17 +307,22 @@ pnpm run dev
 
 # Type checking
 pnpm run typecheck
+
+# Run the locally built CLI (no publish needed)
+pnpm nx build with-zephyr
+node ./libs/with-zephyr/dist/index.js --bundlers rspack /path/to/project
+node ./libs/with-zephyr/dist/index.js --bundlers repack /path/to/react-native-project
 ```
 
 ### Project Structure
 
 ```
 src/
-├── index.ts           # Main CLI entry point
-├── types.ts           # TypeScript type definitions
-├── bundler-configs.ts # Bundler configuration definitions
-├── transformers.ts    # AST transformation functions
-└── package-manager.ts # Package management utilities
+├── bundlers/          # Per-bundler configs + registry
+├── transformers/      # AST transforms (imports, plugin arrays, wrappers, etc.)
+├── package-manager.ts # Package management utilities
+├── index.ts           # CLI entry point and orchestration
+└── types.ts           # Shared types
 ```
 
 ## Contributing

package/dist/index.js

@@ -43515,7 +43515,10 @@ const parseClass = (glob, position)=>{
         true
     ];
 };
-const unescape_unescape = (s, { windowsPathsNoEscape = false } = {})=>windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, '$1') : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2').replace(/\\([^\/])/g, '$1');
+const unescape_unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {})=>{
+    if (magicalBraces) return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, '$1') : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2').replace(/\\([^\/])/g, '$1');
+    return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, '$1') : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, '$1$2').replace(/\\([^\/{}])/g, '$1');
+};
 const types = new Set([
     '!',
     '?',
@@ -43760,7 +43763,7 @@ class ast_AST {
         const dot = allowDot ?? !!this.#options.dot;
         if (this.#root === this) this.#fillNegs();
         if (!this.type) {
-            const noEmpty = this.isStart() && this.isEnd();
+            const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s)=>'string' != typeof s);
             const src = this.#parts.map((p)=>{
                 const [re, _, hasMagic, uflag] = 'string' == typeof p ? ast_AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
                 this.#hasMagic = this.#hasMagic || hasMagic;
@@ -43857,8 +43860,7 @@ class ast_AST {
                 }
             }
             if ('*' === c) {
-                if (noEmpty && '*' === glob) re += starNoEmpty;
-                else re += star;
+                re += noEmpty && '*' === glob ? starNoEmpty : star;
                 hasMagic = true;
                 continue;
             }
@@ -43877,7 +43879,10 @@ class ast_AST {
         ];
     }
 }
-const escape_escape = (s, { windowsPathsNoEscape = false } = {})=>windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, '[$&]') : s.replace(/[?*()[\]\\]/g, '\\$&');
+const escape_escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {})=>{
+    if (magicalBraces) return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, '[$&]') : s.replace(/[?*()[\]\\{}]/g, '\\$&');
+    return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, '[$&]') : s.replace(/[?*()[\]\\]/g, '\\$&');
+};
 const minimatch = (p, pattern, options = {})=>{
     assertValidPattern(pattern);
     if (!options.nocomment && '#' === pattern.charAt(0)) return false;
@@ -44413,13 +44418,19 @@ class esm_Minimatch {
                 if (p !== GLOBSTAR || prev === GLOBSTAR) return;
                 if (void 0 === prev) if (void 0 !== next && next !== GLOBSTAR) pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next;
                 else pp[i] = twoStar;
-                else if (void 0 === next) pp[i - 1] = prev + '(?:\\/|' + twoStar + ')?';
+                else if (void 0 === next) pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + ')?';
                 else if (next !== GLOBSTAR) {
                     pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
                     pp[i + 1] = GLOBSTAR;
                 }
             });
-            return pp.filter((p)=>p !== GLOBSTAR).join('/');
+            const filtered = pp.filter((p)=>p !== GLOBSTAR);
+            if (this.partial && filtered.length >= 1) {
+                const prefixes = [];
+                for(let i = 1; i <= filtered.length; i++)prefixes.push(filtered.slice(0, i).join('/'));
+                return '(?:' + prefixes.join('|') + ')';
+            }
+            return filtered.join('/');
         }).join('|');
         const [open, close] = set.length > 1 ? [
             '(?:',
@@ -44429,6 +44440,7 @@ class esm_Minimatch {
             ''
         ];
         re = '^' + open + re + close + '$';
+        if (this.partial) re = '^(?:\\/|' + open + re.slice(1, -1) + close + ')$';
         if (this.negate) re = '^(?!' + re + ').+$';
         try {
             this.regexp = new RegExp(re, [
@@ -47910,280 +47922,307 @@ const esm_glob = Object.assign(glob_, {
     unescape: unescape_unescape
 });
 esm_glob.glob = esm_glob;
-const BUNDLER_CONFIGS = {
-    webpack: {
-        files: [
-            'webpack.config.js',
-            'webpack.config.ts',
-            'webpack.config.mjs'
-        ],
-        plugin: 'zephyr-webpack-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'compose-plugins',
-                matcher: /composePlugins\s*\(/,
-                transform: 'addToComposePlugins'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            },
-            {
-                type: 'module-exports',
-                matcher: /module\.exports\s*=/,
-                transform: 'wrapModuleExports'
-            }
-        ]
-    },
-    rspack: {
-        files: [
-            'rspack.config.js',
-            'rspack.config.ts',
-            'rspack.config.mjs'
-        ],
-        plugin: 'zephyr-rspack-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'export-wrapped-call',
-                matcher: /export\s+default\s+withZephyr\s*\(\s*\)\s*\(/,
-                transform: 'skipAlreadyWrapped'
-            },
-            {
-                type: 'compose-plugins',
-                matcher: /composePlugins\s*\(/,
-                transform: 'addToComposePlugins'
-            },
-            {
-                type: 'export-default-object',
-                matcher: /export\s+default\s+\{/,
-                transform: 'wrapExportDefault'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            },
-            {
-                type: 'module-exports',
-                matcher: /module\.exports\s*=/,
-                transform: 'wrapModuleExports'
-            }
-        ]
-    },
-    vite: {
-        files: [
-            'vite.config.js',
-            'vite.config.ts',
-            'vite.config.mjs',
-            'vite.config.mts'
-        ],
-        plugin: 'vite-plugin-zephyr',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'define-config-function',
-                matcher: /defineConfig\s*\(\s*\(\s*\)\s*=>\s*\(\s*\{/,
-                transform: 'addToVitePluginsInFunction'
-            },
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addToVitePlugins'
-            },
-            {
-                type: 'export-default',
-                matcher: /export\s+default\s+\{/,
-                transform: 'addToVitePlugins'
-            }
-        ]
-    },
-    rollup: {
-        files: [
-            'rollup.config.js',
-            'rollup.config.ts',
-            'rollup.config.mjs'
-        ],
-        plugin: 'rollup-plugin-zephyr',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'export-array',
-                matcher: /export\s+default\s+\[/,
-                transform: 'addToRollupArrayConfig'
-            },
-            {
-                type: 'module-exports-function',
-                matcher: /module\.exports\s*=\s*\(\s*config\s*\)\s*=>/,
-                transform: 'addToRollupFunction'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            }
-        ]
-    },
-    rolldown: {
-        files: [
-            'rolldown.config.js',
-            'rolldown.config.ts',
-            'rolldown.config.mjs'
-        ],
-        plugin: 'zephyr-rolldown-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addToRolldownPlugins'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            }
-        ]
-    },
-    modernjs: {
-        files: [
-            'modern.config.js',
-            'modern.config.ts',
-            'modern.config.mjs'
-        ],
-        plugin: 'zephyr-modernjs-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addToModernJSPlugins'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            }
-        ]
-    },
-    rspress: {
-        files: [
-            'rspress.config.js',
-            'rspress.config.ts',
-            'rspress.config.mjs'
-        ],
-        plugin: 'zephyr-rspress-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addToRSPressPlugins'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            }
-        ]
-    },
-    parcel: {
-        files: [
-            '.parcelrc',
-            '.parcelrc.json'
-        ],
-        plugin: 'parcel-reporter-zephyr',
-        importName: null,
-        patterns: [
-            {
-                type: 'parcel-reporters',
-                matcher: /"reporters"\s*:\s*\[/,
-                transform: 'addToParcelReporters'
-            }
-        ]
-    },
-    repack: {
-        files: [
-            'rspack.config.js',
-            'rspack.config.ts',
-            'rspack.config.mjs'
-        ],
-        plugin: 'zephyr-repack-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'export-conditional-withzephyr',
-                matcher: /export\s+default\s+.*\?\s*withZephyr\s*\(\s*\)\s*\(/,
-                transform: 'skipAlreadyWrapped'
-            },
-            {
-                type: 'export-function-variable',
-                matcher: /export\s+default\s+(\w+)\s*;?\s*$/,
-                transform: 'wrapExportedFunction'
-            },
-            {
-                type: 'const-function-export',
-                matcher: /const\s+\w+\s*=\s*\w+\s*=>/,
-                transform: 'wrapExportedFunction'
-            }
-        ]
-    },
-    rsbuild: {
-        files: [
-            'rsbuild.config.js',
-            'rsbuild.config.ts',
-            'rsbuild.config.mjs'
-        ],
-        plugin: 'zephyr-rsbuild-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'zephyr-rsbuild-plugin-exists',
-                matcher: /zephyrRSbuildPlugin/,
-                transform: 'skipAlreadyWrapped'
-            },
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addZephyrRSbuildPlugin'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addZephyrRSbuildPlugin'
-            }
-        ]
-    },
-    rslib: {
-        files: [
-            'rslib.config.js',
-            'rslib.config.ts',
-            'rslib.config.mjs'
-        ],
-        plugin: 'zephyr-rsbuild-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'zephyr-rsbuild-plugin-exists',
-                matcher: /zephyrRSbuildPlugin/,
-                transform: 'skipAlreadyWrapped'
-            },
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addZephyrRSbuildPlugin'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addZephyrRSbuildPlugin'
-            }
-        ]
-    }
+const astro_astroConfig = {
+    files: [
+        'astro.config.js',
+        'astro.config.ts',
+        'astro.config.mjs',
+        'astro.config.mts'
+    ],
+    plugin: 'zephyr-astro-integration',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config-function',
+            matcher: /defineConfig\s*\(\s*\(\s*\)\s*=>\s*\(\s*\{/,
+            transform: 'addToAstroIntegrationsInFunctionOrCreate'
+        },
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToAstroIntegrationsOrCreate'
+        },
+        {
+            type: 'export-default',
+            matcher: /export\s+default\s+\{/,
+            transform: 'addToAstroIntegrationsOrCreate'
+        }
+    ]
+};
+const modernjs_modernjsConfig = {
+    files: [
+        'modern.config.js',
+        'modern.config.ts',
+        'modern.config.mjs'
+    ],
+    plugin: 'zephyr-modernjs-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArrayOrCreate'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const parcel_parcelConfig = {
+    files: [
+        '.parcelrc',
+        '.parcelrc.json'
+    ],
+    plugin: 'parcel-reporter-zephyr',
+    importName: null,
+    patterns: [
+        {
+            type: 'parcel-reporters',
+            matcher: /"reporters"\s*:\s*\[/,
+            transform: 'addToParcelReporters'
+        }
+    ]
+};
+const repack_repackConfig = {
+    files: [
+        'rspack.config.js',
+        'rspack.config.ts',
+        'rspack.config.mjs'
+    ],
+    plugin: 'zephyr-repack-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'export-conditional-withzephyr',
+            matcher: /export\s+default\s+.*\?\s*withZephyr\s*\(\s*\)\s*\(/,
+            transform: 'skipAlreadyWrapped'
+        },
+        {
+            type: 'export-function-variable',
+            matcher: /export\s+default\s+(\w+)\s*;?\s*$/,
+            transform: 'wrapExportedFunction'
+        },
+        {
+            type: 'const-function-export',
+            matcher: /const\s+\w+\s*=\s*\w+\s*=>/,
+            transform: 'wrapExportedFunction'
+        }
+    ]
+};
+const rolldown_rolldownConfig = {
+    files: [
+        'rolldown.config.js',
+        'rolldown.config.ts',
+        'rolldown.config.mjs'
+    ],
+    plugin: 'zephyr-rolldown-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArrayOrCreate'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const rollup_rollupConfig = {
+    files: [
+        'rollup.config.js',
+        'rollup.config.ts',
+        'rollup.config.mjs'
+    ],
+    plugin: 'rollup-plugin-zephyr',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'export-array',
+            matcher: /export\s+default\s+\[/,
+            transform: 'addToRollupArrayConfig'
+        },
+        {
+            type: 'module-exports-function',
+            matcher: /module\.exports\s*=\s*\(\s*config\s*\)\s*=>/,
+            transform: 'addToRollupFunction'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const rsbuild_rsbuildConfig = {
+    files: [
+        'rsbuild.config.js',
+        'rsbuild.config.ts',
+        'rsbuild.config.mjs'
+    ],
+    plugin: 'zephyr-rsbuild-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArray'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const rslib_rslibConfig = {
+    files: [
+        'rslib.config.js',
+        'rslib.config.ts',
+        'rslib.config.mjs'
+    ],
+    plugin: 'zephyr-rsbuild-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArray'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const rspack_rspackConfig = {
+    files: [
+        'rspack.config.js',
+        'rspack.config.ts',
+        'rspack.config.mjs'
+    ],
+    plugin: 'zephyr-rspack-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'export-wrapped-call',
+            matcher: /export\s+default\s+withZephyr\s*\(\s*\)\s*\(/,
+            transform: 'skipAlreadyWrapped'
+        },
+        {
+            type: 'define-config',
+            matcher: /export\s+default\s+defineConfig\s*\(/,
+            transform: 'wrapExportDefault'
+        },
+        {
+            type: 'compose-plugins',
+            matcher: /composePlugins\s*\(/,
+            transform: 'addToComposePlugins'
+        },
+        {
+            type: 'export-default-object',
+            matcher: /export\s+default\s+\{/,
+            transform: 'wrapExportDefault'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        },
+        {
+            type: 'module-exports',
+            matcher: /module\.exports\s*=/,
+            transform: 'wrapModuleExports'
+        }
+    ]
+};
+const rspress_rspressConfig = {
+    files: [
+        'rspress.config.js',
+        'rspress.config.ts',
+        'rspress.config.mjs'
+    ],
+    plugin: 'zephyr-rspress-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArrayOrCreate'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const vite_viteConfig = {
+    files: [
+        'vite.config.js',
+        'vite.config.ts',
+        'vite.config.mjs',
+        'vite.config.mts'
+    ],
+    plugin: 'vite-plugin-zephyr',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config-function',
+            matcher: /defineConfig\s*\(\s*\(\s*\)\s*=>\s*\(\s*\{/,
+            transform: 'addToVitePluginsInFunction'
+        },
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToVitePlugins'
+        },
+        {
+            type: 'export-default',
+            matcher: /export\s+default\s+\{/,
+            transform: 'addToVitePlugins'
+        }
+    ]
+};
+const webpack_webpackConfig = {
+    files: [
+        'webpack.config.js',
+        'webpack.config.ts',
+        'webpack.config.mjs'
+    ],
+    plugin: 'zephyr-webpack-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'compose-plugins',
+            matcher: /composePlugins\s*\(/,
+            transform: 'addToComposePlugins'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        },
+        {
+            type: 'module-exports',
+            matcher: /module\.exports\s*=/,
+            transform: 'wrapModuleExports'
+        }
+    ]
 };
 function detectPackageManager(directory = process.cwd()) {
+    if (process.env.npm_config_user_agent) {
+        const userAgent = process.env.npm_config_user_agent.toLowerCase();
+        if (userAgent.includes('pnpm')) return 'pnpm';
+        if (userAgent.includes('yarn')) return 'yarn';
+        if (userAgent.includes('bun')) return 'bun';
+        if (userAgent.includes('npm')) return 'npm';
+    }
     const lockFiles = {
         'pnpm-lock.yaml': 'pnpm',
         'yarn.lock': 'yarn',
@@ -48216,12 +48255,6 @@ function detectPackageManager(directory = process.cwd()) {
             if (fs_0.existsSync(path_0.join(rootDir, 'lerna.json')) || fs_0.existsSync(path_0.join(rootDir, 'yarn.lock')) && rootDir === directory) return 'yarn';
         }
     } catch  {}
-    if (process.env.npm_config_user_agent) {
-        const userAgent = process.env.npm_config_user_agent.toLowerCase();
-        if (userAgent.includes('pnpm')) return 'pnpm';
-        if (userAgent.includes('yarn')) return 'yarn';
-        if (userAgent.includes('bun')) return 'bun';
-    }
     return 'npm';
 }
 function isPackageInstalled(packageName, directory = process.cwd()) {
@@ -48257,8 +48290,8 @@ function installPackage(directory, packageName, packageManager, isDev = true) {
     }
 }
 var lib = __webpack_require__("../../node_modules/.pnpm/@babel+parser@7.28.4/node_modules/@babel/parser/lib/index.js");
-var traverse_lib = __webpack_require__("../../node_modules/.pnpm/@babel+traverse@7.28.4_supports-color@5.5.0/node_modules/@babel/traverse/lib/index.js");
 var generator_lib = __webpack_require__("../../node_modules/.pnpm/@babel+generator@7.28.3/node_modules/@babel/generator/lib/index.js");
+var traverse_lib = __webpack_require__("../../node_modules/.pnpm/@babel+traverse@7.28.4_supports-color@5.5.0/node_modules/@babel/traverse/lib/index.js");
 var types_lib = __webpack_require__("../../node_modules/.pnpm/@babel+types@7.28.4/node_modules/@babel/types/lib/index.js");
 function parseFile(filePath) {
     const content = fs_0.readFileSync(filePath, 'utf8');
@@ -48300,6 +48333,18 @@ function writeFile(filePath, ast) {
     });
     fs_0.writeFileSync(filePath, output.code);
 }
+function hasZephyrPlugin(ast) {
+    let hasPlugin = false;
+    (0, traverse_lib["default"])(ast, {
+        CallExpression (path) {
+            if (types_lib.isIdentifier(path.node.callee, {
+                name: 'withZephyr'
+            })) hasPlugin = true;
+        }
+    });
+    return hasPlugin;
+}
+function skipAlreadyWrapped(_ast) {}
 function addZephyrImport(ast, pluginName, importName) {
     if (!importName) return;
     let hasImport = false;
@@ -48348,19 +48393,44 @@ function addZephyrRequire(ast, pluginName, importName) {
         });
     }
 }
-function transformers_hasZephyrPlugin(ast) {
-    let hasPlugin = false;
+function addToPluginsArray(ast) {
+    (0, traverse_lib["default"])(ast, {
+        ObjectProperty (path) {
+            if (types_lib.isIdentifier(path.node.key, {
+                name: 'plugins'
+            }) && types_lib.isArrayExpression(path.node.value)) path.node.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+        }
+    });
+}
+function addToPluginsArrayOrCreate(ast) {
+    let pluginAdded = false;
     (0, traverse_lib["default"])(ast, {
         CallExpression (path) {
             if (types_lib.isIdentifier(path.node.callee, {
-                name: 'withZephyr'
-            })) hasPlugin = true;
-        },
-        Identifier (path) {
-            if ('withZephyr' === path.node.name && types_lib.isCallExpression(path.parent) && path.parent.callee === path.node) hasPlugin = true;
+                name: 'defineConfig'
+            }) && 1 === path.node.arguments.length && types_lib.isObjectExpression(path.node.arguments[0])) {
+                const configObject = path.node.arguments[0];
+                let pluginsProperty = null;
+                for (const prop of configObject.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                    name: 'plugins'
+                }) && types_lib.isArrayExpression(prop.value)) {
+                    pluginsProperty = prop;
+                    break;
+                }
+                if (pluginsProperty && types_lib.isArrayExpression(pluginsProperty.value)) {
+                    pluginsProperty.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                    pluginAdded = true;
+                } else if (!pluginsProperty) {
+                    const newPluginsProperty = types_lib.objectProperty(types_lib.identifier('plugins'), types_lib.arrayExpression([
+                        types_lib.callExpression(types_lib.identifier('withZephyr'), [])
+                    ]));
+                    configObject.properties.push(newPluginsProperty);
+                    pluginAdded = true;
+                }
+            }
         }
     });
-    return hasPlugin;
+    if (!pluginAdded) addToPluginsArray(ast);
 }
 function addToComposePlugins(ast) {
     (0, traverse_lib["default"])(ast, {
@@ -48376,15 +48446,6 @@ function addToComposePlugins(ast) {
         }
     });
 }
-function addToPluginsArray(ast) {
-    (0, traverse_lib["default"])(ast, {
-        ObjectProperty (path) {
-            if (types_lib.isIdentifier(path.node.key, {
-                name: 'plugins'
-            }) && types_lib.isArrayExpression(path.node.value)) path.node.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
-        }
-    });
-}
 function addToVitePlugins(ast) {
     addToPluginsArray(ast);
 }
@@ -48410,13 +48471,112 @@ function addToVitePluginsInFunction(ast) {
         }
     });
 }
+function addToAstroIntegrations(ast) {
+    (0, traverse_lib["default"])(ast, {
+        ObjectExpression (path) {
+            for (const prop of path.node.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                name: 'integrations'
+            }) && types_lib.isArrayExpression(prop.value)) {
+                prop.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                path.stop();
+                return;
+            }
+        }
+    });
+}
+function addToAstroIntegrationsInFunction(ast) {
+    (0, traverse_lib["default"])(ast, {
+        CallExpression (path) {
+            if (types_lib.isIdentifier(path.node.callee, {
+                name: 'defineConfig'
+            }) && 1 === path.node.arguments.length && types_lib.isArrowFunctionExpression(path.node.arguments[0])) {
+                const arrowFunc = path.node.arguments[0];
+                let objExpr = null;
+                if (types_lib.isParenthesizedExpression(arrowFunc.body) && types_lib.isObjectExpression(arrowFunc.body.expression)) objExpr = arrowFunc.body.expression;
+                else if (types_lib.isObjectExpression(arrowFunc.body)) objExpr = arrowFunc.body;
+                if (objExpr) {
+                    for (const prop of objExpr.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                        name: 'integrations'
+                    }) && types_lib.isArrayExpression(prop.value)) {
+                        prop.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                        break;
+                    }
+                }
+            }
+        }
+    });
+}
+function addToAstroIntegrationsOrCreate(ast) {
+    let integrationAdded = false;
+    (0, traverse_lib["default"])(ast, {
+        CallExpression (path) {
+            if (types_lib.isIdentifier(path.node.callee, {
+                name: 'defineConfig'
+            }) && 1 === path.node.arguments.length && types_lib.isObjectExpression(path.node.arguments[0])) {
+                const configObject = path.node.arguments[0];
+                let integrationsProperty = null;
+                for (const prop of configObject.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                    name: 'integrations'
+                }) && types_lib.isArrayExpression(prop.value)) {
+                    integrationsProperty = prop;
+                    break;
+                }
+                if (integrationsProperty && types_lib.isArrayExpression(integrationsProperty.value)) {
+                    integrationsProperty.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                    integrationAdded = true;
+                } else if (!integrationsProperty) {
+                    const newIntegrationsProperty = types_lib.objectProperty(types_lib.identifier('integrations'), types_lib.arrayExpression([
+                        types_lib.callExpression(types_lib.identifier('withZephyr'), [])
+                    ]));
+                    configObject.properties.push(newIntegrationsProperty);
+                    integrationAdded = true;
+                }
+            }
+        }
+    });
+    if (!integrationAdded) addToAstroIntegrations(ast);
+}
+function addToAstroIntegrationsInFunctionOrCreate(ast) {
+    let integrationAdded = false;
+    (0, traverse_lib["default"])(ast, {
+        CallExpression (path) {
+            if (types_lib.isIdentifier(path.node.callee, {
+                name: 'defineConfig'
+            }) && 1 === path.node.arguments.length && types_lib.isArrowFunctionExpression(path.node.arguments[0])) {
+                const arrowFunc = path.node.arguments[0];
+                let objExpr = null;
+                if (types_lib.isParenthesizedExpression(arrowFunc.body) && types_lib.isObjectExpression(arrowFunc.body.expression)) objExpr = arrowFunc.body.expression;
+                else if (types_lib.isObjectExpression(arrowFunc.body)) objExpr = arrowFunc.body;
+                if (objExpr) {
+                    let integrationsProperty = null;
+                    for (const prop of objExpr.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                        name: 'integrations'
+                    }) && types_lib.isArrayExpression(prop.value)) {
+                        integrationsProperty = prop;
+                        break;
+                    }
+                    if (integrationsProperty && types_lib.isArrayExpression(integrationsProperty.value)) {
+                        integrationsProperty.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                        integrationAdded = true;
+                    } else if (!integrationsProperty) {
+                        const newIntegrationsProperty = types_lib.objectProperty(types_lib.identifier('integrations'), types_lib.arrayExpression([
+                            types_lib.callExpression(types_lib.identifier('withZephyr'), [])
+                        ]));
+                        objExpr.properties.push(newIntegrationsProperty);
+                        integrationAdded = true;
+                    }
+                }
+            }
+        }
+    });
+    if (!integrationAdded) addToAstroIntegrationsInFunction(ast);
+}
 function addToRollupFunction(ast) {
     (0, traverse_lib["default"])(ast, {
         ArrowFunctionExpression (path) {
-            if (1 === path.node.params.length && types_lib.isIdentifier(path.node.params[0], {
-                name: 'config'
-            })) {
-                const pushStatement = types_lib.expressionStatement(types_lib.callExpression(types_lib.memberExpression(types_lib.memberExpression(types_lib.identifier('config'), types_lib.identifier('plugins')), types_lib.identifier('push')), [
+            if (1 === path.node.params.length && types_lib.isIdentifier(path.node.params[0])) {
+                const paramName = path.node.params[0].name;
+                const pushStatement = types_lib.expressionStatement(types_lib.callExpression(types_lib.memberExpression(types_lib.memberExpression(types_lib.identifier(paramName), types_lib.identifier('plugins')), types_lib.identifier('push')), [
                     types_lib.callExpression(types_lib.identifier('withZephyr'), [])
                 ]));
                 if (types_lib.isBlockStatement(path.node.body)) {
@@ -48428,21 +48588,18 @@ function addToRollupFunction(ast) {
         }
     });
 }
-function addToRolldownPlugins(ast) {
-    addToPluginsArray(ast);
-}
-function addToModernJSPlugins(ast) {
-    addToPluginsArray(ast);
-}
-function addToRSPressPlugins(ast) {
-    addToPluginsArray(ast);
-}
-function addToParcelReporters(filePath, pluginName) {
-    const content = fs_0.readFileSync(filePath, 'utf8');
-    const config = JSON.parse(content);
-    if (!config.reporters) config.reporters = [];
-    if (!config.reporters.includes(pluginName)) config.reporters.push(pluginName);
-    fs_0.writeFileSync(filePath, JSON.stringify(config, null, 2));
+function addToRollupArrayConfig(ast) {
+    (0, traverse_lib["default"])(ast, {
+        ExportDefaultDeclaration (path) {
+            if (types_lib.isArrayExpression(path.node.declaration)) {
+                for (const element of path.node.declaration.elements)if (types_lib.isObjectExpression(element)) {
+                    for (const prop of element.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                        name: 'plugins'
+                    }) && types_lib.isArrayExpression(prop.value)) return void prop.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                }
+            }
+        }
+    });
 }
 function wrapModuleExports(ast) {
     (0, traverse_lib["default"])(ast, {
@@ -48451,33 +48608,22 @@ function wrapModuleExports(ast) {
                 name: 'module'
             }) && types_lib.isIdentifier(path.node.left.property, {
                 name: 'exports'
-            })) path.node.right = types_lib.callExpression(types_lib.identifier('withZephyr'), []);
+            })) path.node.right = types_lib.callExpression(types_lib.callExpression(types_lib.identifier('withZephyr'), []), [
+                path.node.right
+            ]);
         }
     });
 }
 function wrapExportDefault(ast) {
     (0, traverse_lib["default"])(ast, {
         ExportDefaultDeclaration (path) {
-            if (types_lib.isObjectExpression(path.node.declaration)) path.node.declaration = types_lib.callExpression(types_lib.callExpression(types_lib.identifier('withZephyr'), []), [
-                path.node.declaration
+            const declaration = path.node.declaration;
+            if (types_lib.isObjectExpression(declaration) || types_lib.isCallExpression(declaration) || types_lib.isAwaitExpression(declaration)) path.node.declaration = types_lib.callExpression(types_lib.callExpression(types_lib.identifier('withZephyr'), []), [
+                declaration
             ]);
         }
     });
 }
-function addToRollupArrayConfig(ast) {
-    (0, traverse_lib["default"])(ast, {
-        ExportDefaultDeclaration (path) {
-            if (types_lib.isArrayExpression(path.node.declaration)) {
-                for (const element of path.node.declaration.elements)if (types_lib.isObjectExpression(element)) {
-                    for (const prop of element.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
-                        name: 'plugins'
-                    }) && types_lib.isArrayExpression(prop.value)) return void prop.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
-                }
-            }
-        }
-    });
-}
-function skipAlreadyWrapped(_ast) {}
 function wrapExportedFunction(ast) {
     (0, traverse_lib["default"])(ast, {
         ExportDefaultDeclaration (path) {
@@ -48498,122 +48644,50 @@ function wrapExportedFunction(ast) {
         }
     });
 }
-function addZephyrRSbuildPlugin(ast) {
-    let hasWithZephyrImport = false;
-    (0, traverse_lib["default"])(ast, {
-        ImportDeclaration (path) {
-            if ('zephyr-rspack-plugin' === path.node.source.value) {
-                const specifiers = path.node.specifiers;
-                for (const spec of specifiers)if (types_lib.isImportSpecifier(spec) && types_lib.isIdentifier(spec.imported, {
-                    name: 'withZephyr'
-                })) hasWithZephyrImport = true;
-            }
-        }
-    });
-    if (!hasWithZephyrImport) {
-        const importDeclaration = types_lib.importDeclaration([
-            types_lib.importSpecifier(types_lib.identifier('withZephyr'), types_lib.identifier('withZephyr'))
-        ], types_lib.stringLiteral('zephyr-rspack-plugin'));
-        (0, traverse_lib["default"])(ast, {
-            Program (path) {
-                const firstImportIndex = path.node.body.findIndex((node)=>types_lib.isImportDeclaration(node));
-                if (firstImportIndex >= 0) path.node.body.splice(firstImportIndex + 1, 0, importDeclaration);
-                else path.node.body.unshift(importDeclaration);
-                path.stop();
-            }
-        });
-    }
-    let hasZephyrPlugin = false;
-    (0, traverse_lib["default"])(ast, {
-        VariableDeclarator (path) {
-            if (types_lib.isIdentifier(path.node.id, {
-                name: 'zephyrRSbuildPlugin'
-            })) hasZephyrPlugin = true;
-        }
-    });
-    if (!hasZephyrPlugin) {
-        const zephyrPluginFunction = types_lib.variableDeclaration('const', [
-            types_lib.variableDeclarator(types_lib.identifier('zephyrRSbuildPlugin'), types_lib.arrowFunctionExpression([], types_lib.objectExpression([
-                types_lib.objectProperty(types_lib.identifier('name'), types_lib.stringLiteral('zephyr-rsbuild-plugin')),
-                types_lib.objectMethod('method', types_lib.identifier('setup'), [
-                    types_lib.identifier('api')
-                ], types_lib.blockStatement([
-                    types_lib.expressionStatement(types_lib.callExpression(types_lib.memberExpression(types_lib.identifier('api'), types_lib.identifier('modifyRspackConfig')), [
-                        types_lib.arrowFunctionExpression([
-                            types_lib.identifier('config')
-                        ], types_lib.blockStatement([
-                            types_lib.variableDeclaration('const', [
-                                types_lib.variableDeclarator(types_lib.identifier('zephyrConfig'), types_lib.awaitExpression(types_lib.callExpression(types_lib.callExpression(types_lib.identifier('withZephyr'), []), [
-                                    types_lib.identifier('config')
-                                ])))
-                            ]),
-                            types_lib.expressionStatement(types_lib.assignmentExpression('=', types_lib.identifier('config'), types_lib.identifier('zephyrConfig')))
-                        ]), true)
-                    ]))
-                ]))
-            ])))
-        ]);
-        (0, traverse_lib["default"])(ast, {
-            Program (path) {
-                let insertIndex = 0;
-                for(let i = 0; i < path.node.body.length; i++)if (types_lib.isImportDeclaration(path.node.body[i])) insertIndex = i + 1;
-                else break;
-                path.node.body.splice(insertIndex, 0, zephyrPluginFunction);
-                path.stop();
-            }
-        });
-        let hasRsbuildPluginImport = false;
-        (0, traverse_lib["default"])(ast, {
-            ImportDeclaration (path) {
-                if ('@rsbuild/core' === path.node.source.value) {
-                    const specifiers = path.node.specifiers;
-                    for (const spec of specifiers)if (types_lib.isImportSpecifier(spec) && types_lib.isIdentifier(spec.imported, {
-                        name: 'RsbuildPlugin'
-                    })) hasRsbuildPluginImport = true;
-                    if (!hasRsbuildPluginImport) specifiers.push(types_lib.importSpecifier(types_lib.identifier('RsbuildPlugin'), types_lib.identifier('RsbuildPlugin')));
-                }
-            }
-        });
-    }
-    (0, traverse_lib["default"])(ast, {
-        ObjectProperty (path) {
-            if (types_lib.isIdentifier(path.node.key, {
-                name: 'plugins'
-            }) && types_lib.isArrayExpression(path.node.value)) {
-                let hasZephyrInPlugins = false;
-                for (const element of path.node.value.elements)if (types_lib.isCallExpression(element) && types_lib.isIdentifier(element.callee, {
-                    name: 'zephyrRSbuildPlugin'
-                })) {
-                    hasZephyrInPlugins = true;
-                    break;
-                }
-                if (!hasZephyrInPlugins) path.node.value.elements.push(types_lib.callExpression(types_lib.identifier('zephyrRSbuildPlugin'), []));
-            }
-        }
-    });
+function addToParcelReporters(filePath, pluginName) {
+    const content = fs_0.readFileSync(filePath, 'utf8');
+    const config = JSON.parse(content);
+    if (!config.reporters) config.reporters = [];
+    if (!config.reporters.includes(pluginName)) config.reporters.push(pluginName);
+    fs_0.writeFileSync(filePath, JSON.stringify(config, null, 2));
 }
+const src_BUNDLER_CONFIGS = {
+    webpack: webpack_webpackConfig,
+    rspack: rspack_rspackConfig,
+    vite: vite_viteConfig,
+    rollup: rollup_rollupConfig,
+    rolldown: rolldown_rolldownConfig,
+    rsbuild: rsbuild_rsbuildConfig,
+    rslib: rslib_rslibConfig,
+    parcel: parcel_parcelConfig,
+    astro: astro_astroConfig,
+    modernjs: modernjs_modernjsConfig,
+    rspress: rspress_rspressConfig,
+    repack: repack_repackConfig
+};
 const TRANSFORMERS = {
     addToComposePlugins: addToComposePlugins,
     addToPluginsArray: addToPluginsArray,
+    addToPluginsArrayOrCreate: addToPluginsArrayOrCreate,
     addToVitePlugins: addToVitePlugins,
     addToVitePluginsInFunction: addToVitePluginsInFunction,
+    addToAstroIntegrations: addToAstroIntegrations,
+    addToAstroIntegrationsInFunction: addToAstroIntegrationsInFunction,
+    addToAstroIntegrationsOrCreate: addToAstroIntegrationsOrCreate,
+    addToAstroIntegrationsInFunctionOrCreate: addToAstroIntegrationsInFunctionOrCreate,
     addToRollupFunction: addToRollupFunction,
     addToRollupArrayConfig: addToRollupArrayConfig,
-    addToRolldownPlugins: addToRolldownPlugins,
-    addToModernJSPlugins: addToModernJSPlugins,
-    addToRSPressPlugins: addToRSPressPlugins,
     wrapModuleExports: wrapModuleExports,
     wrapExportDefault: wrapExportDefault,
     skipAlreadyWrapped: skipAlreadyWrapped,
-    wrapExportedFunction: wrapExportedFunction,
-    addZephyrRSbuildPlugin: addZephyrRSbuildPlugin
+    wrapExportedFunction: wrapExportedFunction
 };
 function normalizePathForOutput(filePath) {
     return filePath.replace(/\\/g, '/');
 }
 function findConfigFiles(directory) {
     const configFiles = [];
-    for (const [bundlerName, config] of Object.entries(BUNDLER_CONFIGS))for (const fileName of config.files){
+    for (const [bundlerName, config] of Object.entries(src_BUNDLER_CONFIGS))for (const fileName of config.files){
         const pattern = `${directory}/**/${fileName}`.replace(/\\/g, '/');
         const matches = esm_glob.sync(pattern, {
             ignore: [
@@ -48656,7 +48730,7 @@ function checkHasZephyr(filePath, config) {
         }
         {
             const ast = parseFile(filePath);
-            return transformers_hasZephyrPlugin(ast);
+            return hasZephyrPlugin(ast);
         }
     } catch (error) {
         console.warn(source.yellow(`Warning: Could not parse ${normalizePathForOutput(filePath)}: ${error.message}`));

package/dist/zephyr-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "timestamp": "2025-09-26T21:08:22.949Z",
+  "timestamp": "2025-12-01T16:09:14.657Z",
   "dependencies": {},
   "zeVars": {}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "with-zephyr",
-  "version": "0.0.0-canary.2",
+  "version": "0.0.0-canary.20",
   "description": "A codemod to automatically add withZephyr plugin to bundler configurations",
   "main": "dist/index.js",
   "repository": {
@@ -38,7 +38,7 @@
     "@types/node": "^24.5.2",
     "@rslib/core": "^0.13.3",
     "typescript": "^5.9.2",
-    "zephyr-rsbuild-plugin": "0.0.0-canary.2"
+    "zephyr-rsbuild-plugin": "0.0.0-canary.20"
   },
   "keywords": [
     "zephyr",
@@ -50,6 +50,7 @@
     "rspack",
     "rsbuild",
     "rslib",
+    "astro",
     "modernjs",
     "rolldown",
     "rspress"