@storybook-astro/framework 1.0.3 → 1.1.1

package/dist/{chunk-KSDXET2L.js → chunk-4HECE7IW.js}

@@ -1,23 +1,26 @@
 import {
-  applyMswHandlers,
   resolveSanitizationOptions,
   resolveStoryModuleMock,
   sanitizeRenderPayload,
   selectStoryRules,
-  withStoryModuleMocks
-} from "./chunk-C5OH4VBR.js";
-import {
-  vitePluginAstroComponentMarker
-} from "./chunk-E4LB75JN.js";
+  serializeSanitizationOptions,
+  withStoryModuleMocks,
+  withStoryRuleCleanups
+} from "./chunk-V76WSNSP.js";
 import {
   createVirtualModulePlugin,
   resolveRulesConfigFilePath,
   ssrLoadModuleWithFsFallback,
+  viteAstroContainerRenderersPlugin,
   vitePluginAstroFontsFallback,
+  vitePluginAstroIntegrationOptsFallback,
   vitePluginAstroRoutesFallback,
   vitePluginAstroVueFallback,
   vitePluginStorybookAstroMiddleware
-} from "./chunk-7GHEQUPV.js";
+} from "./chunk-POHTFYST.js";
+import {
+  vitePluginAstroComponentMarker
+} from "./chunk-E4LB75JN.js";
 import {
   importAstroConfig
 } from "./chunk-DNGQBPT7.js";
@@ -36,6 +39,42 @@ function viteStorybookRendererFallbackPlugin(integrations) {
   });
 }
 
+// src/viteStorybookAstroRendererPlugin.ts
+var packageName = "@storybook-astro/framework";
+function viteStorybookAstroRendererPlugin(options) {
+  const pluginName = "storybook-astro:renderer-module";
+  const virtualModuleId = "virtual:storybook-astro-renderer";
+  const isProduction = options.mode === "production";
+  const isStaticMode = options.renderMode === "static";
+  return createVirtualModulePlugin({
+    pluginName,
+    virtualModuleId,
+    load() {
+      if (!isProduction) {
+        return `export * from '${packageName}/renderer/renderer-dev.ts';`;
+      }
+      if (isStaticMode) {
+        return `export * from '${packageName}/renderer/renderer-static.ts';`;
+      }
+      return [
+        `import { createServerRenderer } from '${packageName}/renderer/renderer-server.ts';`,
+        `const renderer = createServerRenderer(${JSON.stringify(
+          {
+            serverUrl: options.server?.serverUrl,
+            authToken: options.server?.authToken,
+            authHeader: options.server?.authHeader
+          },
+          null,
+          2
+        )});`,
+        "export const render = renderer.render;",
+        "export const init = renderer.init;",
+        "export const applyStyles = renderer.applyStyles;"
+      ].join("\n");
+    }
+  });
+}
+
 // src/vitePluginAstroBuildPrerender.ts
 import { createRequire } from "module";
 import { mkdir, readFile, readdir, writeFile } from "fs/promises";
@@ -165,43 +204,46 @@ async function prerenderStories(options) {
       const selectedRules = await selectStoryRules({
         configModule: rulesConfigModule,
         configFilePath: options.storyRulesConfigFilePath,
-        mode: "production",
         story: {
           id: story.id,
           title: story.title,
           name: story.name
         }
       });
-      await applyMswHandlers(selectedRules.mswHandlers);
       if (selectedRules.moduleMocks.size > 0) {
         viteServer.moduleGraph.invalidateAll();
       }
-      const html = await withStoryModuleMocks(selectedRules.moduleMocks, async () => {
-        const modulePath = resolveImportPath(story.importPath, options.resolveFrom);
-        const storyModule = await viteServer.ssrLoadModule(modulePath);
-        const meta = isRecord(storyModule.default) ? storyModule.default : {};
-        const storyExport = isRecord(storyModule[story.exportName]) ? storyModule[story.exportName] : {};
-        if (typeof meta.component !== "function") {
-          throw new Error(
-            `Unable to prerender story "${story.id}". Missing default export component in ${story.importPath}.`
+      const html = await withStoryRuleCleanups(selectedRules.cleanups, async () => {
+        return withStoryModuleMocks(selectedRules.moduleMocks, async () => {
+          const modulePath = resolveImportPath(story.importPath, options.resolveFrom);
+          const storyModule = await viteServer.ssrLoadModule(modulePath);
+          const meta = isRecord(storyModule.default) ? storyModule.default : {};
+          const storyExport = isRecord(storyModule[story.exportName]) ? storyModule[story.exportName] : {};
+          if (typeof meta.component !== "function") {
+            throw new Error(
+              `Unable to prerender story "${story.id}". Missing default export component in ${story.importPath}.`
+            );
+          }
+          if (storyExport.component && storyExport.component !== meta.component) {
+            return void 0;
+          }
+          const mergedArgs = mergeStoryArgs(toRecord(meta.args), toRecord(storyExport.args));
+          const { args, slots } = separateSlots(mergedArgs);
+          const processedArgs = await processImageMetadata(args);
+          const sanitizedPayload = sanitizeRenderPayload(
+            {
+              args: processedArgs,
+              slots
+            },
+            sanitizationOptions
+          );
+          return container.renderToString(
+            patchCreateAstroCompat(meta.component),
+            {
+              props: sanitizedPayload.args,
+              slots: sanitizedPayload.slots
+            }
           );
-        }
-        if (storyExport.component && storyExport.component !== meta.component) {
-          return void 0;
-        }
-        const mergedArgs = mergeStoryArgs(toRecord(meta.args), toRecord(storyExport.args));
-        const { args, slots } = separateSlots(mergedArgs);
-        const processedArgs = await processImageMetadata(args);
-        const sanitizedPayload = sanitizeRenderPayload(
-          {
-            args: processedArgs,
-            slots
-          },
-          sanitizationOptions
-        );
-        return container.renderToString(patchCreateAstroCompat(meta.component), {
-          props: sanitizedPayload.args,
-          slots: sanitizedPayload.slots
         });
       });
       if (html !== void 0) {
@@ -214,14 +256,18 @@ async function prerenderStories(options) {
   }
 }
 async function createStorySsrServer(integrations, trackedSpecifiers, resolveFrom) {
-  const { getViteConfig } = await importAstroConfig(resolveFrom);
+  const { getViteConfig, passthroughImageService } = await importAstroConfig(resolveFrom);
   const astroConfig = await getViteConfig(
     { root: resolveFrom },
     {
       configFile: false,
       integrations: await Promise.all(
         integrations.map((integration) => integration.loadIntegration(resolveFrom))
-      )
+      ),
+      // Use the passthrough image service so nested components that use <Image>
+      // from astro:assets render as plain <img> tags without triggering image
+      // optimization (which fails in the Storybook SSR context).
+      image: { service: passthroughImageService() }
     }
   )({
     mode: "production",
@@ -235,6 +281,7 @@ async function createStorySsrServer(integrations, trackedSpecifiers, resolveFrom
     plugins: [
       createProjectAstroResolutionPlugin(resolveFrom),
       vitePluginAstroFontsFallback(),
+      vitePluginAstroIntegrationOptsFallback(),
       vitePluginAstroVueFallback(),
       vitePluginAstroRoutesFallback(),
       {
@@ -476,14 +523,14 @@ async function processImageMetadata(args) {
   const processed = {};
   for (const [key, value] of Object.entries(args)) {
     if (isImageMetadata(value)) {
-      processed[key] = convertImageMetadataToUrl(value);
+      processed[key] = value;
       continue;
     }
     if (Array.isArray(value)) {
       processed[key] = await Promise.all(
         value.map(async (item) => {
           if (isImageMetadata(item)) {
-            return convertImageMetadataToUrl(item);
+            return item;
           }
           if (isRecord(item)) {
             return processImageMetadata(item);
@@ -504,17 +551,6 @@ async function processImageMetadata(args) {
 function isImageMetadata(value) {
   return isRecord(value) && typeof value.src === "string" && ("width" in value || "height" in value || "format" in value);
 }
-function convertImageMetadataToUrl(imageMetadata) {
-  const src = imageMetadata.src;
-  const fsPath = imageMetadata.fsPath;
-  if (typeof src === "string") {
-    return src;
-  }
-  if (typeof fsPath === "string") {
-    return fsPath;
-  }
-  return String(imageMetadata);
-}
 function createProjectAstroResolutionPlugin(resolveFrom) {
   const require2 = createRequire(import.meta.url);
   return {
@@ -535,6 +571,12 @@ function createProjectAstroResolutionPlugin(resolveFrom) {
   };
 }
 
+// src/vitePluginAstroBuildServer.ts
+import { readdir as readdir2 } from "fs/promises";
+import { dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { build } from "vite";
+
 // src/vitePluginAstro.ts
 import { mergeConfig as mergeConfig2 } from "vite";
 var ASTRO_PLUGINS_THAT_ARE_SUPPOSEDLY_NOT_NEEDED_IN_STORYBOOK = [
@@ -586,32 +628,388 @@ async function mergeWithAstroConfig(config, integrations = [], resolveFrom = pro
   });
 }
 
+// src/vite/astroFilesVirtualModulePlugin.ts
+function astroFilesVirtualModulePlugin(astroComponents) {
+  return createVirtualModulePlugin({
+    pluginName: "storybook-astro:virtual-astro-files",
+    virtualModuleId: "virtual:astro-files",
+    load() {
+      const imports = astroComponents.reduce((records, file, index) => {
+        const moduleId = `_astroFile${index}`;
+        return [
+          ...records,
+          {
+            id: moduleId,
+            file,
+            importStatement: `import ${moduleId} from '${file}';`
+          }
+        ];
+      }, []);
+      return [
+        imports.map(({ importStatement }) => importStatement).join("\n"),
+        "export default {",
+        imports.map(({ file, id }) => `'${file}': ${id}`).join(",\n"),
+        "};"
+      ].join("\n");
+    }
+  });
+}
+
+// src/vite/storybookAstroRulesConfigVirtualModulePlugin.ts
+var STORYBOOK_ASTRO_STORY_RULES_CONFIG_VIRTUAL_MODULE_ID = "virtual:storybook-astro-story-rules-config";
+function storybookAstroStoryRulesConfigVirtualModulePlugin(options, resolveFrom = process.cwd()) {
+  return createVirtualModulePlugin({
+    pluginName: "storybook-astro:virtual-story-rules-config",
+    virtualModuleId: STORYBOOK_ASTRO_STORY_RULES_CONFIG_VIRTUAL_MODULE_ID,
+    load() {
+      const configFilePath = resolveRulesConfigFilePath(options, resolveFrom);
+      if (!configFilePath) {
+        return [
+          "const storybookAstroStoryRulesConfig = { rules: [] };",
+          "export default storybookAstroStoryRulesConfig;",
+          "export const storybookAstroStoryRulesConfigFilePath = undefined;"
+        ].join("\n");
+      }
+      const importPath = JSON.stringify(configFilePath.replace(/\\/g, "/"));
+      const configPath = JSON.stringify(configFilePath.replace(/\\/g, "/"));
+      return [
+        `import * as storybookAstroStoryRulesConfigModule from ${importPath};`,
+        "export default storybookAstroStoryRulesConfigModule;",
+        `export const storybookAstroStoryRulesConfigFilePath = ${configPath};`
+      ].join("\n");
+    }
+  });
+}
+
+// src/vite/storybookAstroSanitizationConfigVirtualModulePlugin.ts
+var STORYBOOK_ASTRO_SANITIZATION_CONFIG_VIRTUAL_MODULE_ID = "virtual:storybook-astro-sanitization-config";
+function storybookAstroSanitizationConfigVirtualModulePlugin(options) {
+  return createVirtualModulePlugin({
+    pluginName: "storybook-astro:virtual-sanitization-config",
+    virtualModuleId: STORYBOOK_ASTRO_SANITIZATION_CONFIG_VIRTUAL_MODULE_ID,
+    load() {
+      const serializedConfig = serializeSanitizationOptions(options);
+      return `export default ${serializedConfig};`;
+    }
+  });
+}
+
+// src/vite/storybookAstroServerAuthConfigVirtualModulePlugin.ts
+var STORYBOOK_ASTRO_SERVER_AUTH_CONFIG_VIRTUAL_MODULE_ID = "virtual:storybook-astro-server-auth-config";
+function storybookAstroServerAuthConfigVirtualModulePlugin(options) {
+  const authToken = normalizeOptionalString(options?.authToken);
+  const authHeader = normalizeAuthHeader(options?.authHeader);
+  return createVirtualModulePlugin({
+    pluginName: "storybook-astro:virtual-server-auth-config",
+    virtualModuleId: STORYBOOK_ASTRO_SERVER_AUTH_CONFIG_VIRTUAL_MODULE_ID,
+    load() {
+      return [
+        `export const storybookAstroServerAuthToken = ${authToken ? JSON.stringify(authToken) : "undefined"};`,
+        `export const storybookAstroServerAuthHeader = ${JSON.stringify(authHeader)};`
+      ].join("\n");
+    }
+  });
+}
+function normalizeOptionalString(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalizedValue = value.trim();
+  return normalizedValue || void 0;
+}
+function normalizeAuthHeader(value) {
+  const normalizedValue = normalizeOptionalString(value);
+  return (normalizedValue ?? "authorization").toLowerCase();
+}
+
+// src/vitePluginAstroBuildServer.ts
+var moduleRoot = resolve2(dirname(fileURLToPath(import.meta.url)), ".");
+var packageRoot = resolve2(moduleRoot, "..");
+function vitePluginAstroBuildServer(options) {
+  const integrations = options.integrations ?? [];
+  const resolveFrom = options.resolveFrom ?? process.cwd();
+  const storiesMap = /* @__PURE__ */ new Map();
+  const trackedSpecifiers = collectTrackedSpecifiers2(integrations);
+  const staticEntrypointRefs = /* @__PURE__ */ new Map();
+  const componentEntrypointRefs = /* @__PURE__ */ new Map();
+  let storybookStaticOutDir = resolve2(resolveFrom, "storybook-static");
+  return {
+    name: "storybook-astro:build-server",
+    apply: "build",
+    enforce: "post",
+    configResolved(config) {
+      storybookStaticOutDir = resolve2(resolveFrom, config.build.outDir ?? "storybook-static");
+    },
+    resolveId(id, importer) {
+      if (id.endsWith(".astro") && importer) {
+        const absoluteAstroPath = resolve2(dirname(importer), id);
+        if (!storiesMap.has(absoluteAstroPath)) {
+          storiesMap.set(absoluteAstroPath, /* @__PURE__ */ new Set());
+        }
+        storiesMap.get(absoluteAstroPath)?.add(importer);
+      }
+      if (id.startsWith("virtual:astro-static-module/")) {
+        return `\0${id}`;
+      }
+      if (id.startsWith("virtual:astro-component-module/")) {
+        return `\0${id}`;
+      }
+    },
+    load(id) {
+      if (id.startsWith("\0virtual:astro-static-module/")) {
+        const encodedSpecifier = id.replace("\0virtual:astro-static-module/", "");
+        const specifier = decodeURIComponent(encodedSpecifier);
+        if (isClientEntrypoint2(specifier)) {
+          return [`export { default } from '${specifier}';`, `export * from '${specifier}';`].join("\n");
+        }
+        return [`import '${specifier}';`, "export default undefined;"].join("\n");
+      }
+      if (id.startsWith("\0virtual:astro-component-module/")) {
+        const encodedSpecifier = id.replace("\0virtual:astro-component-module/", "");
+        const specifier = decodeURIComponent(encodedSpecifier);
+        return [`export { default } from '${specifier}';`, `export * from '${specifier}';`].join("\n");
+      }
+    },
+    async buildStart() {
+      integrations.forEach((integration) => {
+        const entrypoint = integration.renderer.client?.entrypoint;
+        if (entrypoint) {
+          this.addWatchFile(entrypoint);
+        }
+      });
+      trackedSpecifiers.forEach((specifier) => {
+        const fileReferenceId = this.emitFile({
+          type: "chunk",
+          id: toStaticVirtualId2(specifier)
+        });
+        staticEntrypointRefs.set(specifier, fileReferenceId);
+      });
+      const srcRoot = resolve2(resolveFrom, "src/components");
+      const specifiers = await collectHydratableSourceModules2(srcRoot);
+      specifiers.forEach((specifier) => {
+        const fileReferenceId = this.emitFile({
+          type: "chunk",
+          id: toComponentVirtualId2(specifier)
+        });
+        componentEntrypointRefs.set(specifier, fileReferenceId);
+      });
+    },
+    async writeBundle() {
+      const astroComponents = Array.from(storiesMap.keys());
+      const staticModuleMap = buildStaticModuleMap2(
+        this,
+        staticEntrypointRefs,
+        componentEntrypointRefs
+      );
+      const serverOutDir = resolve2(dirname(storybookStaticOutDir), "storybook-server");
+      await buildAstroServer({
+        astroComponents,
+        integrations,
+        sanitization: options.sanitization,
+        storyRules: options.storyRules,
+        server: options.server,
+        outDir: serverOutDir,
+        staticModuleMap,
+        resolveFrom
+      });
+    }
+  };
+}
+async function buildAstroServer(options) {
+  const buildConfig = {
+    root: resolve2(packageRoot, "src/server"),
+    ssr: {
+      noExternal: /(@astrojs\/.+|react|react-dom)/
+    },
+    build: {
+      ssr: true,
+      outDir: options.outDir,
+      emptyOutDir: true,
+      sourcemap: true,
+      manifest: false,
+      rollupOptions: {
+        input: resolve2(packageRoot, "src/server/index.ts"),
+        treeshake: true
+      }
+    },
+    plugins: [
+      astroFilesVirtualModulePlugin(options.astroComponents),
+      storybookAstroSanitizationConfigVirtualModulePlugin(options.sanitization),
+      storybookAstroStoryRulesConfigVirtualModulePlugin(options.storyRules, options.resolveFrom),
+      storybookAstroServerAuthConfigVirtualModulePlugin(options.server),
+      viteAstroContainerRenderersPlugin(options.integrations, {
+        mode: "production",
+        staticModuleMap: options.staticModuleMap
+      })
+    ]
+  };
+  const finalConfig = await mergeWithAstroConfig(
+    buildConfig,
+    options.integrations,
+    options.resolveFrom,
+    "production",
+    "build"
+  );
+  await build(finalConfig);
+}
+function collectTrackedSpecifiers2(integrations) {
+  const specifiers = /* @__PURE__ */ new Set(["astro:scripts/page.js", "astro:scripts/before-hydration.js"]);
+  integrations.forEach((integration) => {
+    const entrypoint = integration.renderer.client?.entrypoint;
+    if (entrypoint) {
+      specifiers.add(entrypoint);
+    }
+  });
+  return specifiers;
+}
+function buildStaticModuleMap2(pluginContext, staticEntrypointRefs, componentEntrypointRefs) {
+  const map = {};
+  staticEntrypointRefs.forEach((fileReferenceId, specifier) => {
+    const fileName = pluginContext.getFileName(fileReferenceId);
+    if (fileName) {
+      map[specifier] = toPublicPath2(fileName);
+    }
+  });
+  componentEntrypointRefs.forEach((fileReferenceId, specifier) => {
+    const fileName = pluginContext.getFileName(fileReferenceId);
+    if (fileName) {
+      map[specifier] = toPublicPath2(fileName);
+    }
+  });
+  return map;
+}
+function toStaticVirtualId2(specifier) {
+  return `virtual:astro-static-module/${encodeURIComponent(specifier)}`;
+}
+function toComponentVirtualId2(specifier) {
+  return `virtual:astro-component-module/${encodeURIComponent(specifier)}`;
+}
+function isClientEntrypoint2(specifier) {
+  return specifier.startsWith("@astrojs/") && specifier.endsWith("/client.js");
+}
+function toPublicPath2(fileName) {
+  return `./${fileName}`;
+}
+async function collectHydratableSourceModules2(srcRoot) {
+  const modules = [];
+  async function walk(directory) {
+    let entries;
+    try {
+      entries = await readdir2(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    await Promise.all(
+      entries.map(async (entry) => {
+        const absolutePath = resolve2(directory, entry.name);
+        if (entry.isDirectory()) {
+          await walk(absolutePath);
+          return;
+        }
+        if (!entry.isFile()) {
+          return;
+        }
+        const normalizedPath = absolutePath.replace(/\\/g, "/");
+        if (!isHydratableSourceFile2(normalizedPath)) {
+          return;
+        }
+        if (isNonHydratableSourceFile2(normalizedPath)) {
+          return;
+        }
+        modules.push(normalizedPath);
+      })
+    );
+  }
+  await walk(srcRoot);
+  return modules;
+}
+function isHydratableSourceFile2(input) {
+  return /\.(jsx|tsx|vue|svelte|js|ts)$/.test(input);
+}
+function isNonHydratableSourceFile2(input) {
+  return /\.stories\.[jt]sx?$|\.stories\.vue$|\.stories\.svelte$|\.(spec|test)\.[jt]sx?$/.test(
+    input
+  );
+}
+
+// src/vitePluginAstroToolbarFallback.ts
+var TOOLBAR_INTERNAL_STUB = `
+export const loadDevToolbarApps = async () => [];
+`;
+function vitePluginAstroToolbarFallback() {
+  const VIRTUAL_ID = "astro:toolbar:internal";
+  const RESOLVED_ID = "\0" + VIRTUAL_ID;
+  return {
+    name: "storybook-astro-toolbar-fallback",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_ID) {
+        return RESOLVED_ID;
+      }
+    },
+    load(id) {
+      if (id === RESOLVED_ID) {
+        return { code: TOOLBAR_INTERNAL_STUB };
+      }
+    }
+  };
+}
+
 // src/preset.ts
 var core = {
   builder: "@storybook/builder-vite",
-  renderer: "@storybook-astro/renderer"
+  // Use import.meta.resolve so Storybook receives an absolute file:// URL
+  // to the renderer preset rather than a bare package specifier.  When
+  // package managers like pnpm use strict node_modules isolation, bare
+  // specifiers are resolved from the *project root*, where the renderer
+  // (a dep of this framework, not the user's project) is not hoisted.
+  // The absolute URL is resolved from *this* file's location where the
+  // renderer is always accessible as a direct dependency.
+  renderer: import.meta.resolve("@storybook-astro/renderer")
 };
 var viteFinal = async (config, { configType, presets }) => {
   const options = await presets.apply("frameworkOptions");
-  const { vitePlugin: storybookAstroMiddlewarePlugin, viteConfig } = await vitePluginStorybookAstroMiddleware(options);
   if (!config.plugins) {
     config.plugins = [];
   }
   const integrations = options.integrations ?? [];
   const resolveFrom = options.resolveFrom ?? process.cwd();
+  const renderMode = options.renderMode ?? "server";
   const mode = configType === "DEVELOPMENT" ? "development" : "production";
   const command = configType === "DEVELOPMENT" ? "serve" : "build";
   resolveSanitizationOptions(options.sanitization);
+  config.envPrefix = mergeEnvPrefixes(config.envPrefix, "STORYBOOK_");
+  const { vitePlugin: storybookAstroMiddlewarePlugin, viteConfig } = await vitePluginStorybookAstroMiddleware(options);
   config.plugins.push(
-    storybookAstroMiddlewarePlugin,
     viteStorybookRendererFallbackPlugin(integrations),
+    viteStorybookAstroRendererPlugin({
+      mode,
+      renderMode,
+      server: options.server
+    }),
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     vitePluginAstroComponentMarker(),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    vitePluginAstroBuildPrerender(options),
-    vitePluginAstroVueFallback(),
-    ...viteConfig.plugins
+    vitePluginAstroIntegrationOptsFallback(),
+    vitePluginAstroToolbarFallback(),
+    vitePluginAstroVueFallback()
   );
+  if (configType === "DEVELOPMENT") {
+    config.plugins.push(storybookAstroMiddlewarePlugin, ...viteConfig.plugins);
+  } else if (renderMode === "static") {
+    config.plugins.push(vitePluginAstroBuildPrerender(options));
+  } else {
+    config.plugins.push(vitePluginAstroBuildServer(options));
+  }
+  if (configType !== "DEVELOPMENT") {
+    config.build = {
+      ...config.build ?? {},
+      manifest: true
+    };
+    config.build.rollupOptions = {
+      ...config.build.rollupOptions ?? {},
+      preserveEntrySignatures: "strict"
+    };
+  }
   if (!config.resolve) {
     config.resolve = {};
   }
@@ -632,29 +1030,47 @@ var viteFinal = async (config, { configType, presets }) => {
   if (!finalConfig.optimizeDeps.exclude) {
     finalConfig.optimizeDeps.exclude = [];
   }
-  if (!finalConfig.optimizeDeps.exclude.includes("@astrojs/vue")) {
-    finalConfig.optimizeDeps.exclude.push("@astrojs/vue");
+  for (const pkg of ["@astrojs/vue", "@astrojs/react", "@astrojs/preact"]) {
+    if (!finalConfig.optimizeDeps.exclude.includes(pkg)) {
+      finalConfig.optimizeDeps.exclude.push(pkg);
+    }
   }
   if (!finalConfig.optimizeDeps.exclude.includes("@storybook-astro/renderer")) {
     finalConfig.optimizeDeps.exclude.push("@storybook-astro/renderer");
   }
+  const integrationVirtualModules = [
+    "virtual:@astrojs/vue/app",
+    "virtual:astro:vue-app",
+    "astro:react:opts",
+    "astro:preact:opts",
+    "astro:toolbar:internal"
+  ];
   if (!finalConfig.optimizeDeps.esbuildOptions) {
     finalConfig.optimizeDeps.esbuildOptions = {};
   }
   if (!finalConfig.optimizeDeps.esbuildOptions.external) {
     finalConfig.optimizeDeps.esbuildOptions.external = [];
   }
-  const vueVirtualModules = ["virtual:@astrojs/vue/app", "virtual:astro:vue-app"];
-  for (const mod of vueVirtualModules) {
+  for (const mod of integrationVirtualModules) {
     if (!finalConfig.optimizeDeps.esbuildOptions.external.includes(mod)) {
       finalConfig.optimizeDeps.esbuildOptions.external.push(mod);
     }
   }
+  const optimizeDepsMut = finalConfig.optimizeDeps;
+  const rolldownOpts = optimizeDepsMut.rolldownOptions ?? {};
+  rolldownOpts.external = Array.from(
+    /* @__PURE__ */ new Set([...rolldownOpts.external ?? [], ...integrationVirtualModules])
+  );
+  optimizeDepsMut.rolldownOptions = rolldownOpts;
   return finalConfig;
 };
+function mergeEnvPrefixes(existing, additionalPrefix) {
+  const prefixes = Array.isArray(existing) ? existing : existing ? [existing] : [];
+  return Array.from(/* @__PURE__ */ new Set([...prefixes, additionalPrefix]));
+}
 
 export {
   core,
   viteFinal
 };
-//# sourceMappingURL=chunk-KSDXET2L.js.map
+//# sourceMappingURL=chunk-4HECE7IW.js.map