Hook Behavior Differences Between Rolldown and Rollup

buildStart() {
  // ✅ Will execute in Vite 8 dev
  // ⚠️ Will NOT execute in Vite 7 dev (only runs during build)
  initializeCache()
}

moduleParsed(info) {
  // ⚠️ Code that directly manipulates the AST may behave differently between the two
  const ast = info.ast
  // ast.type, ast.body and other basic fields are usually consistent
  // But some node sub-properties may differ
}

renderChunk(code, chunk) {
  // Rollup: chunk only has standard fields
  // Rolldown (Env API): chunk may have extra fields like environmentName

  // ✅ Safe: only use standard Rollup fields
  console.log(chunk.fileName, chunk.isEntry, chunk.exports)

  // ⚠️ Caution: Rolldown extension fields
  // const env = chunk.environmentName  // Does not exist under Rollup
}

// ✅ Basic usage, supported by both
const result = await this.resolve("some-module", "/path/to/importer.ts")

// ⚠️ Advanced options (Rollup supports; Rolldown may differ)
const result = await this.resolve("some-module", importer, {
  skipSelf: true,        // Usually supported
  custom: { ... },       // May differ
})

import type { Plugin } from "vite"

export function compatPlugin(): Plugin {
  return {
    name: "compat-plugin",
    renderChunk(code, chunk) {
      // Safely detect Rolldown extension fields
      const isRolldown = "environmentName" in chunk
      const envName = isRolldown ? (chunk as typeof chunk & { environmentName?: string }).environmentName : "unknown"

      if (isRolldown && envName === "ssr") {
        // Special handling for Rolldown + SSR environment
        return { code: `/* ssr */ ${code}`, map: null }
      }

      return null
    },
  }
}

transform(code, id) {
  // ✅ Prefer string operations; don't depend on AST format
  if (!code.includes("import.meta.DEBUG")) return null

  return {
    code: code.replace(/import\.meta\.DEBUG/g, JSON.stringify(process.env.DEBUG ?? false)),
    map: null,
  }
}

// ✅ These usages are fully consistent between Rollup and Rolldown
const SAFE_PATTERN = {
  resolveId: true, // ✅
  load: true, // ✅
  transform: true, // ✅
  generateBundle: true, // ✅

  // Build-mode only (both support)
  renderChunk: true,
  writeBundle: true,

  // Use with caution
  moduleParsed: "careful", // AST format differences
  this_parse: "careful", // Same as above
  this_resolve_advanced: "careful", // options differences
}

Checklist for migrating to Vite 8:

□ buildStart will now be called in dev — check for side effects
□ Plugin uses this.parse() or moduleParsed AST — test OXC format compatibility
□ renderChunk accesses chunk object fields — use only standard Rollup fields
□ Uses the custom option in this.resolve() — verify consistent behavior
□ Plugin execution order relies on assumptions — use enforce to control explicitly

// Review the following plugin and identify which parts may cause issues
// when migrating from Vite 7 to Vite 8.
// Then propose fixes.

import type { Plugin } from "vite"

export function problemPlugin(): Plugin {
  let initialized = false

  return {
    name: "problem-plugin",

    // A: buildStart does global initialization
    buildStart() {
      if (initialized) return // ← Problem: in Vite 8 dev, after the first trigger, initialized becomes true
      initialized = true
      expensiveInit()
    },

    // B: relies on Acorn AST format
    moduleParsed(info) {
      const exports = info.ast.body
        .filter((node: any) => node.type === "ExportNamedDeclaration")
        .flatMap((node: any) => node.specifiers.map((s: any) => s.exported.name))
      console.log("exports:", exports)
    },

    // C: renderChunk uses extension fields
    renderChunk(code, chunk) {
      // @ts-ignore
      if (chunk.environmentName === "ssr") {
        return { code: `"use server";\n${code}`, map: null }
      }
      return null
    },
  }
}

function expensiveInit() {}