fix(cli): externalize postcss/lightningcss from the dts bundle

`vp pack --dts` inlined postcss's `.d.ts` into the declaration bundle
and failed with 61 MISSING_EXPORT errors for postcss type names.
postcss exposes its public types via `declare namespace postcss {
export {...} }` + `export = postcss` — a CJS namespace shape the dts
bundler cannot map named imports onto.

`externalDtsTypeOnlyPlugin` previously rewrote postcss/lightningcss
imports to type-only via regex, which neither parsed reliably for
default+named imports nor addressed the `export =` mismatch. Replace
it with a `resolveId` hook that marks postcss/lightningcss external
whenever imported from a `.d.ts` file, so emitted declarations keep
`import type { X } from 'postcss'` instead of inlining postcss's
`.d.ts` — standard dts-bundler treatment of third-party packages.
Runtime bundling is unaffected (the hook only fires for
declaration-file importers).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: Brooooooklyn

packages/cli/src/pack-bin.ts

@@ -13,53 +13,42 @@ import { cac } from 'cac';
 
 import { resolveViteConfig } from './resolve-vite-config.ts';
 
+// Matches a `.d.ts` / `.d.mts` / `.d.cts` importer.
+const RE_DTS = /\.d\.[cm]?ts$/;
+// Bare specifier for postcss / lightningcss (root or any subpath).
+const EXTERNAL_DTS_PKG_RE = /^(?:postcss|lightningcss)(?:\/|$)/;
+
 /**
- * Rolldown plugin that transforms value imports/exports to type-only in external
- * packages' .d.ts files. Some packages (e.g. postcss, lightningcss) use
- * `import { X }` and `export { X } from` instead of their type-only equivalents,
- * which causes MISSING_EXPORT warnings from the DTS bundler.
+ * Rolldown plugin that keeps `postcss` / `lightningcss` external to the DTS
+ * bundle.
+ *
+ * The DTS bundler resolves these packages and tries to inline their `.d.ts`
+ * files. postcss ships its public types as a CJS `export = postcss` over a
+ * `declare namespace postcss { export { AtRule, ... } }` (see
+ * postcss/lib/postcss.d.ts), and its ESM types entry (postcss.d.mts) re-exports
+ * those names with `export { AtRule, ... } from './postcss.js'`. The bundler
+ * cannot map named imports onto an `export =`'d namespace's members, so every
+ * consumer `import type { AtRule } from 'postcss'` becomes a MISSING_EXPORT
+ * error.
  *
- * Since .d.ts files contain only type information, all imports/exports are
- * inherently type-only, so this transformation is always safe.
+ * Marking these packages external for `.d.ts` importers leaves the import
+ * untouched in the emitted declarations (`import type { AtRule } from 'postcss'`),
+ * which is how third-party packages should be treated in a DTS bundle anyway.
+ * They are only externalized when imported *from a declaration file*, so runtime
+ * bundling is unaffected.
  */
-const EXTERNAL_DTS_INTERNAL_RE = /node_modules\/(postcss|lightningcss)\/.*\.d\.(ts|mts|cts)$/;
-// Match consumer .d.ts files that import from postcss/lightningcss.
-// In CI (installed from tgz): node_modules/vite-plus-core/dist/...
-// In local development (symlinked workspace): packages/core/dist/...
-const EXTERNAL_DTS_CONSUMER_RE =
-  /(?:vite-plus-core|packages\/core)\/.*lightningcssOptions\.d\.ts$|(?:vite-plus-core|packages\/core)\/dist\/.*\.d\.ts$/;
-const EXTERNAL_DTS_FIX_RE = new RegExp(
-  `${EXTERNAL_DTS_INTERNAL_RE.source}|${EXTERNAL_DTS_CONSUMER_RE.source}`,
-);
-
 function externalDtsTypeOnlyPlugin() {
   return {
     name: 'vite-plus:external-dts-type-only',
-    transform: {
-      filter: { id: { include: [EXTERNAL_DTS_FIX_RE] } },
-      handler(code: string, rawId: string) {
+    resolveId: {
+      order: 'pre' as const,
+      handler(id: string, importer: string | undefined) {
         // Normalize Windows backslash paths to forward slashes for regex matching
-        const id = rawId.replaceAll('\\', '/');
-        if (EXTERNAL_DTS_INTERNAL_RE.test(id)) {
-          // postcss/lightningcss internal files: transform imports only
-          // (exports may include value re-exports like `export const Features`).
-          // A type-only import statement cannot mix a default binding with named
-          // bindings, so fold `import D, { N } from 'x'` into a single named
-          // clause (`{ default as D, N }`) before the generic prepend runs.
-          return code
-            .replace(/^import\s+(\w+)\s*,\s*\{/gm, 'import type { default as $1,')
-            .replace(/^(import\s+)(?!type\s)/gm, 'import type ');
+        const normalizedImporter = importer?.replaceAll('\\', '/');
+        if (normalizedImporter && RE_DTS.test(normalizedImporter) && EXTERNAL_DTS_PKG_RE.test(id)) {
+          return { id, external: true };
         }
-        // Consumer files: only transform imports from postcss/lightningcss
-        return code
-          .replace(
-            /^import\s+(\w+)\s*,\s*\{([^}]*)\}\s*from\s+(['"](?:postcss|lightningcss)['"])/gm,
-            'import type { default as $1,$2} from $3',
-          )
-          .replace(
-            /^(import\s+)(?!type\s)(.+from\s+['"](?:postcss|lightningcss)['"])/gm,
-            'import type $2',
-          );
+        return undefined;
       },
     },
   };
@@ -153,8 +142,7 @@ cli
         : [viteConfig.pack ?? {}];
       for (const packConfig of packConfigs) {
         const merged = { ...packConfig, ...flags };
-        // Inject plugin to fix MISSING_EXPORT warnings from external .d.ts files
-        // (postcss, lightningcss use `import`/`export` instead of `import type`/`export type`)
+        // Keep postcss/lightningcss external to the dts bundle (see plugin doc)
         if (merged.dts) {
           const existingPlugins = Array.isArray(merged.plugins) ? merged.plugins : [];
           merged.plugins = [...existingPlugins, externalDtsTypeOnlyPlugin()];