@storybook-astro/framework 1.2.0 → 1.3.0-canary.1

package/dist/chunk-H3XZHW6Z.js

@@ -0,0 +1,1402 @@
+import {
+  vitePluginAstroComponentMarker
+} from "./chunk-E4LB75JN.js";
+import {
+  createAstroRenderHandler,
+  ensureAstroPassthroughImageService,
+  resolveSanitizationOptions,
+  serializeSanitizationOptions
+} from "./chunk-TWAO2IQW.js";
+import {
+  createVirtualModule,
+  resolveRulesConfigFilePath,
+  ssrLoadModuleWithFsFallback,
+  viteAstroContainerRenderersPlugin,
+  vitePluginAstroFontsFallback,
+  vitePluginAstroIntegrationOptsFallback,
+  vitePluginAstroRoutesFallback,
+  vitePluginAstroVueFallback,
+  vitePluginStoryModuleMocks,
+  vitePluginStorybookAstroMiddleware
+} from "./chunk-AYYMNFI6.js";
+import {
+  importAstroConfig
+} from "./chunk-PUTCAN6X.js";
+import {
+  resolveStoryModuleMock
+} from "./chunk-B5HHF6FC.js";
+
+// src/preset.ts
+import { dirname as dirname3 } from "path";
+
+// src/viteStorybookRendererFallbackPlugin.ts
+function viteStorybookRendererFallbackPlugin(integrations) {
+  const safeIntegrations = integrations ?? [];
+  return createVirtualModule({
+    pluginName: "storybook-renderer-fallback",
+    virtualModuleId: "virtual:storybook-renderer-fallback",
+    load() {
+      return safeIntegrations.filter((integration) => integration.storybookEntryPreview).map(
+        (integration) => `export * as ${integration.name} from '${integration.storybookEntryPreview}';`
+      ).join("\n");
+    }
+  });
+}
+
+// src/viteStorybookAstroRendererPlugin.ts
+import { fileURLToPath } from "url";
+var rendererDevModulePath = fileURLToPath(new URL("./renderer/renderer-dev.js", import.meta.url));
+var rendererStaticModulePath = fileURLToPath(new URL("./renderer/renderer-static.js", import.meta.url));
+var rendererServerModulePath = fileURLToPath(new URL("./renderer/renderer-server.js", import.meta.url));
+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 createVirtualModule({
+    pluginName,
+    virtualModuleId,
+    load() {
+      if (!isProduction) {
+        return `export * from ${JSON.stringify(normalizePath(rendererDevModulePath))};`;
+      }
+      if (isStaticMode) {
+        return `export * from ${JSON.stringify(normalizePath(rendererStaticModulePath))};`;
+      }
+      return [
+        `import { createServerRenderer } from ${JSON.stringify(normalizePath(rendererServerModulePath))};`,
+        `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");
+    }
+  });
+}
+function normalizePath(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/vitePluginAstroBuildPrerender.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
+import { resolve as resolve3 } from "path";
+
+// src/vitePluginAstroBuildShared.ts
+import { createHash } from "crypto";
+import { access, copyFile, mkdir, readFile, readdir, stat } from "fs/promises";
+import { dirname, resolve } from "path";
+function resolveVirtualBuildModuleId(id) {
+  if (id.startsWith("virtual:astro-static-module/")) {
+    return `\0${id}`;
+  }
+  if (id.startsWith("virtual:astro-component-module/")) {
+    return `\0${id}`;
+  }
+}
+function loadVirtualBuildModule(id) {
+  if (id.startsWith("\0virtual:astro-static-module/")) {
+    const encodedSpecifier = id.replace("\0virtual:astro-static-module/", "");
+    const specifier = decodeURIComponent(encodedSpecifier);
+    if (isClientEntrypoint(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 withoutPrefix = id.replace("\0virtual:astro-component-module/", "");
+    const encodedSpecifier = withoutPrefix.replace(/\?.*$/, "");
+    const specifier = decodeURIComponent(encodedSpecifier);
+    return [`export { default } from '${specifier}';`, `export * from '${specifier}';`].join("\n");
+  }
+}
+async function emitBuildEntrypoints(options) {
+  const { pluginContext, integrations, resolveFrom } = options;
+  integrations.forEach((integration) => {
+    const entrypoint = integration.renderer.client?.entrypoint;
+    if (entrypoint) {
+      pluginContext.addWatchFile(entrypoint);
+    }
+  });
+  options.trackedSpecifiers.forEach((specifier) => {
+    const fileReferenceId = pluginContext.emitFile({
+      type: "chunk",
+      id: toStaticVirtualId(specifier),
+      name: createEntrypointName(resolveFrom, specifier)
+    });
+    options.staticEntrypointRefs.set(specifier, fileReferenceId);
+  });
+}
+async function emitHydratedComponentEntriesFromAstroFile(options) {
+  const hydratedComponentPaths = await collectHydratedComponentPaths(options.astroFilePath);
+  for (const resolvedImportPath of hydratedComponentPaths) {
+    if (options.componentEntrypointRefs.has(resolvedImportPath)) {
+      continue;
+    }
+    const fileReferenceId = options.pluginContext.emitFile({
+      type: "chunk",
+      id: toComponentChunkId(resolvedImportPath),
+      name: createEntrypointName(options.resolveFrom, resolvedImportPath)
+    });
+    options.componentEntrypointRefs.set(resolvedImportPath, fileReferenceId);
+  }
+}
+async function collectHydratedComponentPaths(astroFilePath) {
+  const localImportSpecifiers = await readLocalImportSpecifiers(astroFilePath);
+  const hydratedComponentPaths = [];
+  for (const specifier of localImportSpecifiers) {
+    const resolvedImportPath = await resolveLocalImportPath(astroFilePath, specifier);
+    if (!resolvedImportPath) {
+      continue;
+    }
+    if (!isHydratableSourceFile(resolvedImportPath) || isNonHydratableSourceFile(resolvedImportPath)) {
+      continue;
+    }
+    if (/\.(jsx|tsx)$/.test(resolvedImportPath) && !await hasDefaultExport(resolvedImportPath)) {
+      continue;
+    }
+    hydratedComponentPaths.push(resolvedImportPath);
+  }
+  return hydratedComponentPaths;
+}
+function collectTrackedSpecifiers(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 buildStaticModuleMap(pluginContext, staticEntrypointRefs, componentEntrypointRefs) {
+  const map = {};
+  staticEntrypointRefs.forEach((fileReferenceId, specifier) => {
+    const fileName = pluginContext.getFileName(fileReferenceId);
+    if (fileName) {
+      map[specifier] = toPublicPath(fileName);
+    }
+  });
+  componentEntrypointRefs.forEach((fileReferenceId, specifier) => {
+    const fileName = pluginContext.getFileName(fileReferenceId);
+    if (fileName) {
+      map[specifier] = toPublicPath(fileName);
+    }
+  });
+  return map;
+}
+function toPublicPath(fileName) {
+  return `./${fileName}`;
+}
+function stripQuery(input) {
+  return input?.replace(/\?.*$/, "");
+}
+function relativePathFromRoot(resolveFrom, filePath) {
+  return filePath.slice(resolveFrom.length).replace(/^[/\\]+/, "");
+}
+async function copyPath(sourcePath, targetPath) {
+  const sourceStats = await stat(sourcePath);
+  if (sourceStats.isDirectory()) {
+    await mkdir(targetPath, { recursive: true });
+    const entries = await readdir(sourcePath, { withFileTypes: true });
+    await Promise.all(
+      entries.map(
+        (entry) => copyPath(resolve(sourcePath, entry.name), resolve(targetPath, entry.name))
+      )
+    );
+    return;
+  }
+  await mkdir(dirname(targetPath), { recursive: true });
+  await copyFile(sourcePath, targetPath);
+}
+function buildSnapshotFilePath(resolveFrom, filePath, snapshotDirName) {
+  const normalizedResolveFrom = resolveFrom.replace(/\\/g, "/").replace(/\/$/, "");
+  const normalizedFilePath = filePath.replace(/\\/g, "/");
+  if (normalizedFilePath.startsWith(`${normalizedResolveFrom}/`)) {
+    return `${snapshotDirName}/${relativePathFromRoot(resolveFrom, filePath)}`.replace(/\\/g, "/");
+  }
+  return `${snapshotDirName}/__external/${normalizedFilePath.replace(/^[/\\]+/, "")}`.replace(
+    /\\/g,
+    "/"
+  );
+}
+async function copyRuntimeSnapshot(options) {
+  const runtimeInputFiles = /* @__PURE__ */ new Set([
+    ...options.astroComponents,
+    ...options.storyRulesConfigFilePath ? [options.storyRulesConfigFilePath] : [],
+    ...await listRuntimeConfigFiles(options.resolveFrom)
+  ]);
+  const copiedFiles = /* @__PURE__ */ new Set();
+  for (const runtimeInputFile of runtimeInputFiles) {
+    await copyLocalRuntimeDependencies(runtimeInputFile, options, copiedFiles);
+  }
+}
+async function hasDefaultExport(absPath) {
+  try {
+    const source = await readFile(absPath, "utf-8");
+    return /export\s+default\b/.test(source) || /export\s*\{[^}]*\bdefault\b/.test(source);
+  } catch {
+    return true;
+  }
+}
+function toStaticVirtualId(specifier) {
+  return `virtual:astro-static-module/${encodeURIComponent(specifier)}`;
+}
+function toComponentVirtualId(specifier) {
+  return `virtual:astro-component-module/${encodeURIComponent(specifier)}?component-wrapper`;
+}
+function toComponentChunkId(specifier) {
+  return /\.(svelte|vue)$/.test(specifier) ? specifier : toComponentVirtualId(specifier);
+}
+function createEntrypointName(resolveFrom, specifier) {
+  const normalizedResolveFrom = resolveFrom.replace(/\\/g, "/");
+  const normalizedSpecifier = specifier.replace(/\\/g, "/");
+  const relativeName = normalizedSpecifier.startsWith(`${normalizedResolveFrom}/`) ? normalizedSpecifier.slice(normalizedResolveFrom.length + 1) : normalizedSpecifier.split("/").slice(-2).join("/");
+  const sanitizedName = relativeName.replace(/[^a-zA-Z0-9/_-]/g, "_").replace(/_+/g, "_");
+  const hash = createHash("sha1").update(normalizedSpecifier).digest("hex").slice(0, 8);
+  return `${sanitizedName}-${hash}`;
+}
+function isClientEntrypoint(specifier) {
+  return specifier.startsWith("@astrojs/") && specifier.endsWith("/client.js");
+}
+function isHydratableSourceFile(input) {
+  return /\.(jsx|tsx|vue|svelte)$/.test(input);
+}
+function isNonHydratableSourceFile(input) {
+  return /\.stories\.[jt]sx?$|\.stories\.vue$|\.stories\.svelte$|\.(spec|test)\.[jt]sx?$/.test(
+    input
+  );
+}
+async function listRuntimeConfigFiles(resolveFrom) {
+  const candidates = [
+    "package.json",
+    "tsconfig.json",
+    "tsconfig.base.json",
+    "jsconfig.json",
+    "astro.config.mjs",
+    "astro.config.js",
+    "astro.config.ts",
+    "vite.config.js",
+    "vite.config.ts",
+    "svelte.config.js"
+  ];
+  const existing = [];
+  await Promise.all(
+    candidates.map(async (candidate) => {
+      const filePath = resolve(resolveFrom, candidate);
+      try {
+        await access(filePath);
+        existing.push(filePath);
+      } catch {
+        return;
+      }
+    })
+  );
+  return existing;
+}
+async function copyLocalRuntimeDependencies(sourcePath, options, copiedFiles) {
+  const normalizedSourcePath = sourcePath.replace(/\\/g, "/");
+  if (copiedFiles.has(normalizedSourcePath)) {
+    return;
+  }
+  copiedFiles.add(normalizedSourcePath);
+  const snapshotRelativePath = buildSnapshotFilePath(
+    options.resolveFrom,
+    normalizedSourcePath,
+    options.snapshotDirName
+  );
+  await copyPath(
+    normalizedSourcePath,
+    resolve(dirname(options.snapshotRoot), snapshotRelativePath)
+  );
+  const localImportSpecifiers = await readLocalImportSpecifiers(normalizedSourcePath);
+  for (const specifier of localImportSpecifiers) {
+    const resolvedDependency = await resolveLocalImportPath(normalizedSourcePath, specifier);
+    if (!resolvedDependency) {
+      continue;
+    }
+    await copyLocalRuntimeDependencies(resolvedDependency, options, copiedFiles);
+  }
+}
+async function readLocalImportSpecifiers(filePath) {
+  if (!/\.(astro|[cm]?[jt]sx?|vue|svelte)$/.test(filePath)) {
+    return [];
+  }
+  const source = await readFile(filePath, "utf-8");
+  const matches = source.matchAll(
+    /(?:import|export)\s+(?:[^'"`]*?\s+from\s+)?['"`]([^'"`]+)['"`]|import\(\s*['"`]([^'"`]+)['"`]\s*\)/g
+  );
+  return Array.from(matches, (match) => match[1] ?? match[2]).filter(
+    (specifier) => Boolean(specifier) && specifier.startsWith(".")
+  );
+}
+async function resolveLocalImportPath(importerPath, specifier) {
+  const basePath = resolve(dirname(importerPath), specifier);
+  const candidates = [
+    basePath,
+    `${basePath}.ts`,
+    `${basePath}.tsx`,
+    `${basePath}.js`,
+    `${basePath}.jsx`,
+    `${basePath}.mjs`,
+    `${basePath}.cjs`,
+    `${basePath}.astro`,
+    `${basePath}.vue`,
+    `${basePath}.svelte`,
+    resolve(basePath, "index.ts"),
+    resolve(basePath, "index.tsx"),
+    resolve(basePath, "index.js"),
+    resolve(basePath, "index.jsx"),
+    resolve(basePath, "index.mjs"),
+    resolve(basePath, "index.cjs"),
+    resolve(basePath, "index.astro"),
+    resolve(basePath, "index.vue"),
+    resolve(basePath, "index.svelte")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const candidateStats = await stat(candidate);
+      if (candidateStats.isFile()) {
+        return candidate.replace(/\\/g, "/");
+      }
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+
+// src/productionRenderRuntime.ts
+import { resolve as resolve2 } from "path";
+
+// src/storySsrVite.ts
+import { createRequire } from "module";
+import { createServer, mergeConfig } from "vite";
+async function createStorySsrViteServer(options) {
+  const { getViteConfig, passthroughImageService } = await importAstroConfig(options.resolveFrom);
+  const astroConfig = await getViteConfig(
+    { root: options.resolveFrom },
+    {
+      configFile: false,
+      integrations: await Promise.all(
+        options.integrations.map((integration) => integration.loadIntegration(options.resolveFrom))
+      ),
+      image: { service: passthroughImageService() }
+    }
+  )({
+    mode: "production",
+    command: "serve"
+  });
+  const config = mergeConfig(astroConfig, {
+    appType: "custom",
+    server: {
+      middlewareMode: true
+    },
+    ssr: {
+      // Keep Astro runtime classes in the Vite SSR graph so containers and
+      // components share SlotString/HTMLString instances during prerendering.
+      noExternal: /^astro(\/.+)?$/
+    },
+    plugins: [
+      createProjectAstroResolutionPlugin(options.resolveFrom),
+      vitePluginAstroFontsFallback(),
+      vitePluginAstroIntegrationOptsFallback(),
+      vitePluginAstroVueFallback(),
+      vitePluginAstroRoutesFallback(),
+      vitePluginStoryModuleMocks(),
+      createTrackedSpecifierStubPlugin(options.trackedSpecifiers)
+    ]
+  });
+  const viteServer = await createServer(config);
+  await viteServer.pluginContainer.buildStart({});
+  return viteServer;
+}
+async function loadRulesConfigModule(viteServer, configFilePath) {
+  if (!configFilePath) {
+    return void 0;
+  }
+  try {
+    return await ssrLoadModuleWithFsFallback(viteServer, configFilePath, {
+      fixStacktrace: true
+    });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Unable to load framework.options.storyRules config module at ${configFilePath}: ${reason}`
+    );
+  }
+}
+function createClientModuleResolver(integrations, staticModuleMap) {
+  return function resolveClientModule(specifier) {
+    if (Object.hasOwn(staticModuleMap, specifier)) {
+      return staticModuleMap[specifier];
+    }
+    const normalizedSpecifier = specifier.replace(/\\/g, "/").replace(/\?.*$/, "");
+    if (Object.hasOwn(staticModuleMap, normalizedSpecifier)) {
+      return staticModuleMap[normalizedSpecifier];
+    }
+    for (const integration of integrations) {
+      const resolution = integration.resolveClient(specifier);
+      if (resolution) {
+        return resolution;
+      }
+    }
+  };
+}
+async function createProductionAstroContainer(options) {
+  ensureAstroPassthroughImageService();
+  const containerModule = await options.viteServer.ssrLoadModule("astro/container");
+  const ViteAstroContainer = containerModule.experimental_AstroContainer;
+  const container = await ViteAstroContainer.create({
+    resolve: async (specifier) => {
+      const mockedModule = resolveStoryModuleMock(specifier);
+      if (mockedModule) {
+        return mockedModule;
+      }
+      const resolution = options.resolveClientModule(specifier);
+      if (resolution) {
+        return resolution;
+      }
+      return specifier;
+    }
+  });
+  await addContainerRenderers(
+    container,
+    options.integrations,
+    options.resolveClientModule,
+    options.viteServer
+  );
+  return container;
+}
+async function addContainerRenderers(container, integrations, resolveClientModule, viteServer) {
+  for (const integration of integrations) {
+    const serverRenderer = integration.renderer.server;
+    if (serverRenderer) {
+      const serverRendererModule = await viteServer.ssrLoadModule(serverRenderer.entrypoint);
+      const renderer = serverRendererModule.default ?? serverRendererModule;
+      if (integration.name === "solid" && isRecord(renderer)) {
+        container.addServerRenderer({
+          name: serverRenderer.name,
+          renderer: {
+            ...renderer,
+            name: serverRenderer.name
+          }
+        });
+      } else {
+        container.addServerRenderer({
+          name: serverRenderer.name,
+          renderer
+        });
+      }
+    }
+    const clientRenderer = integration.renderer.client;
+    if (clientRenderer) {
+      const resolvedEntrypoint = resolveClientModule(clientRenderer.entrypoint) ?? clientRenderer.entrypoint;
+      container.addClientRenderer({
+        name: clientRenderer.name,
+        entrypoint: resolvedEntrypoint
+      });
+    }
+  }
+}
+function createProjectAstroResolutionPlugin(resolveFrom) {
+  const require2 = createRequire(import.meta.url);
+  return {
+    name: "storybook-astro:resolve-project-astro-shared",
+    enforce: "pre",
+    resolveId(id) {
+      if (id !== "astro" && !id.startsWith("astro/")) {
+        return null;
+      }
+      try {
+        return require2.resolve(id, {
+          paths: [resolveFrom]
+        });
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+function createTrackedSpecifierStubPlugin(trackedSpecifiers) {
+  return {
+    name: "storybook-astro:shared-ssr-stubs",
+    resolveId(id) {
+      if (trackedSpecifiers.has(id)) {
+        return `\0storybook-astro-shared-ssr-stub:${encodeURIComponent(id)}`;
+      }
+      return null;
+    },
+    load(id) {
+      if (id.startsWith("\0storybook-astro-shared-ssr-stub:")) {
+        return "export default undefined;";
+      }
+      return null;
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/productionRenderRuntime.ts
+async function createProductionRenderRuntime(options) {
+  const viteServer = await createStorySsrViteServer({
+    integrations: options.integrations,
+    trackedSpecifiers: options.trackedSpecifiers,
+    resolveFrom: options.resolveFrom
+  });
+  try {
+    const rulesConfigModule = await loadRulesConfigModule(
+      viteServer,
+      options.storyRulesConfigFilePath
+    );
+    const resolveClientModule = createClientModuleResolver(
+      options.integrations,
+      options.staticModuleMap
+    );
+    const astroContainer = await createProductionAstroContainer({
+      integrations: options.integrations,
+      resolveClientModule,
+      viteServer
+    });
+    const loadModule = async (moduleId) => {
+      return await viteServer.ssrLoadModule(
+        options.resolveComponentId?.(moduleId) ?? moduleId
+      );
+    };
+    const renderAstroStory = createAstroRenderHandler({
+      container: astroContainer,
+      sanitization: options.sanitization,
+      rulesConfigFilePath: options.storyRulesConfigFilePath,
+      resolveRulesConfigModule: () => rulesConfigModule,
+      loadModule: async (moduleId) => {
+        const loadedModule = await loadModule(moduleId);
+        return {
+          default: loadedModule.default
+        };
+      },
+      invalidateModuleGraph: () => {
+        viteServer.moduleGraph.invalidateAll();
+      }
+    });
+    return {
+      loadModule,
+      renderAstroStory,
+      close: () => viteServer.close()
+    };
+  } catch (error) {
+    await viteServer.close();
+    throw error;
+  }
+}
+async function renderProductionStoryToHtml(options) {
+  const storyModulePath = resolveProjectImportPath(options.story.importPath, options.resolveFrom);
+  const componentPath = resolveProjectImportPath(options.story.componentPath, options.resolveFrom);
+  const storyModule = await options.runtime.loadModule(storyModulePath);
+  const defaultStoryMeta = isRecord2(storyModule.default) ? storyModule.default : {};
+  const selectedStoryExport = isRecord2(storyModule[options.story.exportName]) ? storyModule[options.story.exportName] : {};
+  if (typeof defaultStoryMeta.component !== "function") {
+    throw new Error(
+      `Unable to prerender story "${options.story.id}". Missing default export component in ${options.story.importPath}.`
+    );
+  }
+  if (selectedStoryExport.component && selectedStoryExport.component !== defaultStoryMeta.component) {
+    return void 0;
+  }
+  const storyArgs = mergeMetaArgsWithStoryArgs(
+    toRecord(defaultStoryMeta.args),
+    toRecord(selectedStoryExport.args)
+  );
+  const { componentArgs, storySlots } = separateStorySlots(storyArgs);
+  return options.runtime.renderAstroStory({
+    component: componentPath,
+    args: componentArgs,
+    slots: storySlots,
+    story: {
+      id: options.story.id,
+      title: options.story.title,
+      name: options.story.name
+    }
+  });
+}
+function resolveProjectImportPath(importPath, resolveFrom) {
+  if (importPath.startsWith("./") || importPath.startsWith("../")) {
+    return resolve2(resolveFrom, importPath);
+  }
+  return importPath;
+}
+function mergeMetaArgsWithStoryArgs(metaArgs, storyArgs) {
+  return {
+    ...metaArgs ?? {},
+    ...storyArgs ?? {}
+  };
+}
+function separateStorySlots(storyArgs) {
+  const componentArgs = { ...storyArgs };
+  const storySlots = componentArgs.slots;
+  delete componentArgs.slots;
+  if (!isRecord2(storySlots)) {
+    return {
+      componentArgs,
+      storySlots: {}
+    };
+  }
+  return {
+    componentArgs,
+    storySlots
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function toRecord(value) {
+  if (!isRecord2(value)) {
+    return void 0;
+  }
+  return value;
+}
+
+// src/vitePluginAstroBuildPrerender.ts
+var PRERENDERED_STORIES_FILE = "astro-prerendered-stories.json";
+function vitePluginAstroBuildPrerender(options) {
+  const integrations = options.integrations ?? [];
+  const resolveFrom = options.resolveFrom ?? process.cwd();
+  const storyRulesConfigFilePath = resolveRulesConfigFilePath(options.storyRules, resolveFrom);
+  const trackedSpecifiers = collectTrackedSpecifiers(integrations);
+  const staticEntrypointRefs = /* @__PURE__ */ new Map();
+  const componentEntrypointRefs = /* @__PURE__ */ new Map();
+  let outDir = resolve3(resolveFrom, "storybook-static");
+  return {
+    name: "storybook-astro:build-prerender",
+    apply: "build",
+    enforce: "post",
+    configResolved(config) {
+      outDir = resolve3(resolveFrom, config.build.outDir ?? "storybook-static");
+    },
+    async resolveId(id, importer) {
+      const importerPath = stripQuery(importer);
+      if (importerPath?.endsWith(".astro")) {
+        await emitHydratedComponentEntriesFromAstroFile({
+          pluginContext: this,
+          astroFilePath: importerPath,
+          resolveFrom,
+          componentEntrypointRefs
+        });
+      }
+      return resolveVirtualBuildModuleId(id);
+    },
+    load(id) {
+      return loadVirtualBuildModule(id);
+    },
+    async buildStart() {
+      await emitBuildEntrypoints({
+        pluginContext: this,
+        integrations,
+        resolveFrom,
+        trackedSpecifiers,
+        staticEntrypointRefs
+      });
+    },
+    async writeBundle(_outputOptions, bundle) {
+      const staticModuleMap = buildStaticModuleMap(
+        this,
+        staticEntrypointRefs,
+        componentEntrypointRefs
+      );
+      const astroStories = await collectAstroStories(outDir);
+      if (astroStories.length === 0) {
+        await writePrerenderedStoriesFile(outDir, {});
+        return;
+      }
+      const prerenderedStories = await prerenderAstroStories({
+        astroStories,
+        integrations,
+        sanitization: options.sanitization,
+        storyRulesConfigFilePath,
+        staticModuleMap,
+        trackedSpecifiers,
+        resolveFrom,
+        bundle
+      });
+      await writePrerenderedStoriesFile(outDir, prerenderedStories);
+    }
+  };
+}
+async function writePrerenderedStoriesFile(outDir, payload) {
+  await mkdir2(outDir, { recursive: true });
+  await writeFile(resolve3(outDir, PRERENDERED_STORIES_FILE), JSON.stringify(payload), "utf-8");
+}
+async function prerenderAstroStories(options) {
+  const runtime = await createProductionRenderRuntime({
+    integrations: options.integrations,
+    sanitization: options.sanitization,
+    storyRulesConfigFilePath: options.storyRulesConfigFilePath,
+    staticModuleMap: options.staticModuleMap,
+    trackedSpecifiers: options.trackedSpecifiers,
+    resolveFrom: options.resolveFrom
+  });
+  const assetPathMap = buildAssetPathMap(options.bundle);
+  try {
+    const output = {};
+    for (const story of options.astroStories) {
+      const html = await renderProductionStoryToHtml({
+        story,
+        runtime,
+        resolveFrom: options.resolveFrom
+      });
+      if (html !== void 0) {
+        output[story.id] = rewriteAssetPaths(html, assetPathMap);
+      }
+    }
+    return output;
+  } finally {
+    await runtime.close();
+  }
+}
+async function collectAstroStories(outDir) {
+  const indexFile = resolve3(outDir, "index.json");
+  const indexRaw = await readFile2(indexFile, "utf-8");
+  const indexJson = JSON.parse(indexRaw);
+  return Object.values(indexJson.entries ?? {}).filter((entry) => entry.type === "story" && entry.componentPath?.endsWith(".astro")).map((entry) => {
+    if (!entry.id || !entry.importPath || !entry.exportName || !entry.componentPath) {
+      throw new Error(`Encountered an invalid Storybook index entry in ${indexFile}.`);
+    }
+    return {
+      id: entry.id,
+      importPath: entry.importPath,
+      componentPath: entry.componentPath,
+      exportName: entry.exportName,
+      title: entry.title,
+      name: entry.name
+    };
+  });
+}
+function buildAssetPathMap(bundle) {
+  const exactMap = /* @__PURE__ */ new Map();
+  const stemMap = /* @__PURE__ */ new Map();
+  for (const chunk of Object.values(bundle)) {
+    if (chunk.type !== "asset") {
+      continue;
+    }
+    const asset = chunk;
+    if (asset.originalFileNames && asset.originalFileNames.length > 0) {
+      for (const originalPath of asset.originalFileNames) {
+        exactMap.set(originalPath, `/${asset.fileName}`);
+      }
+    }
+    const baseName = asset.fileName.split("/").pop() ?? "";
+    const stemMatch = baseName.match(/^(.+)-[A-Za-z0-9]{6,12}\.(png|jpe?g|gif|webp|svg|avif|ico)$/);
+    if (stemMatch) {
+      stemMap.set(`${stemMatch[1]}.${stemMatch[2]}`, `/${asset.fileName}`);
+    }
+  }
+  return { exactMap, stemMap };
+}
+function rewriteAssetPaths(html, assetPathMap) {
+  const { exactMap, stemMap } = assetPathMap;
+  if (exactMap.size === 0 && stemMap.size === 0) {
+    return html;
+  }
+  return html.replace(/\/@fs\/[^"']+/g, (match) => {
+    const pathOnly = match.replace(/\?.*$/, "");
+    const fsPath = pathOnly.slice("/@fs".length);
+    const absolutePath = fsPath.startsWith("//") ? fsPath.slice(1) : fsPath;
+    const exact = exactMap.get(absolutePath);
+    if (exact) {
+      return exact;
+    }
+    const baseName = absolutePath.split("/").pop() ?? "";
+    const stemHit = stemMap.get(baseName);
+    if (stemHit) {
+      return stemHit;
+    }
+    return match;
+  });
+}
+
+// src/vitePluginAstroBuildServer.ts
+import { dirname as dirname2, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { build } from "vite";
+
+// src/vitePluginAstro.ts
+import { mergeConfig as mergeConfig2 } from "vite";
+var ASTRO_PLUGINS_THAT_ARE_SUPPOSEDLY_NOT_NEEDED_IN_STORYBOOK = [
+  "@astro/plugin-actions",
+  "@astrojs/vite-plugin-astro-ssr-manifest",
+  "astro-content-virtual-mod-plugin",
+  "astro:actions",
+  "astro:build:normal",
+  "astro:container",
+  "astro:content-asset-propagation",
+  "astro:content-imports",
+  "astro:content-listen",
+  "astro:dev-toolbar",
+  "astro:head-metadata",
+  "astro:html",
+  "astro:i18n",
+  "astro:integration-container",
+  "astro:jsx",
+  "astro:markdown",
+  "astro:postprocess",
+  "astro:prefetch",
+  "astro:scanner",
+  "astro:scripts:page-ssr",
+  "astro:server",
+  "astro:vite-plugin-env",
+  "astro:vite-plugin-file-url"
+];
+async function mergeWithAstroConfig(config, integrations = [], resolveFrom = process.cwd(), mode = "development", command = "serve") {
+  const { getViteConfig } = await importAstroConfig(resolveFrom);
+  const safeIntegrations = integrations ?? [];
+  const astroConfig = await getViteConfig(
+    {},
+    {
+      configFile: false,
+      integrations: await Promise.all(
+        safeIntegrations.map((integration) => integration.loadIntegration(resolveFrom))
+      )
+    }
+  )({
+    mode,
+    command
+  });
+  const filteredPlugins = astroConfig.plugins.flat().filter(
+    (plugin) => plugin && "name" in plugin && !ASTRO_PLUGINS_THAT_ARE_SUPPOSEDLY_NOT_NEEDED_IN_STORYBOOK.includes(plugin.name)
+  );
+  return mergeConfig2(config, {
+    ...astroConfig,
+    plugins: filteredPlugins
+  });
+}
+
+// src/vite/sanitizeConfigPlugin.ts
+var SANITIZE_CONFIG_MODULE_ID = "virtual:storybook-astro/sanitize-config";
+function sanitizeConfigPlugin(options) {
+  return createVirtualModule({
+    pluginName: "storybook-astro:sanitize-config",
+    virtualModuleId: SANITIZE_CONFIG_MODULE_ID,
+    load() {
+      const serializedConfig = serializeSanitizationOptions(options);
+      return `export default ${serializedConfig};`;
+    }
+  });
+}
+
+// src/vite/serverAuthPlugin.ts
+var SERVER_AUTH_MODULE_ID = "virtual:storybook-astro/server-auth";
+function serverAuthPlugin(options) {
+  const authToken = normalizeOptionalString(options?.authToken);
+  const authHeader = normalizeAuthHeader(options?.authHeader);
+  return createVirtualModule({
+    pluginName: "storybook-astro:server-auth",
+    virtualModuleId: SERVER_AUTH_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/vite/serverRuntimePlugin.ts
+import { relative } from "path";
+var SERVER_RUNTIME_MODULE_ID = "virtual:storybook-astro/server-runtime";
+var integrationsModuleId = "@storybook-astro/framework/integrations";
+function getIntegrationFactoryName(integration) {
+  return integration.factoryName ?? integration.name;
+}
+function serverRuntimePlugin(options) {
+  return createVirtualModule({
+    pluginName: "storybook-astro:server-runtime",
+    virtualModuleId: SERVER_RUNTIME_MODULE_ID,
+    load() {
+      const storyRulesConfigFilePath = resolveRulesConfigFilePath(options.storyRules, options.resolveFrom);
+      const storyRulesConfigRelativePath = storyRulesConfigFilePath ? relative(options.resolveFrom, storyRulesConfigFilePath).replace(/\\/g, "/") : void 0;
+      const integrations = options.integrations ?? [];
+      const runtimeConfig = {
+        snapshotDirName: options.snapshotDirName,
+        storyRulesConfigRelativePath,
+        componentPathMap: options.componentPathMap,
+        staticModuleMap: options.staticModuleMap,
+        staticCssMap: options.staticCssMap,
+        trackedSpecifiers: options.trackedSpecifiers
+      };
+      return [
+        createIntegrationImports(integrations),
+        `export const runtimeConfig = ${serializeValue(runtimeConfig)};`,
+        `export const integrations = [${createIntegrationFactoryCalls(integrations)}];`
+      ].join("\n");
+    }
+  });
+}
+function createIntegrationImports(integrations) {
+  const factoryNames = Array.from(new Set(integrations.map(getIntegrationFactoryName)));
+  if (factoryNames.length === 0) {
+    return "";
+  }
+  return `import { ${factoryNames.join(", ")} } from ${JSON.stringify(integrationsModuleId)};`;
+}
+function createIntegrationFactoryCalls(integrations) {
+  return integrations.map((integration) => `${getIntegrationFactoryName(integration)}(${serializeValue(integration.options)})`).join(", ");
+}
+function serializeValue(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => serializeValue(entry)).join(", ")}]`;
+  }
+  if (isRecord3(value)) {
+    return `{${Object.entries(value).map(([key, entryValue]) => `${JSON.stringify(key)}: ${serializeValue(entryValue)}`).join(", ")}}`;
+  }
+  throw new Error("Unable to serialize Storybook Astro server runtime configuration.");
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/vitePluginAstroBuildServer.ts
+var moduleRoot = resolve4(dirname2(fileURLToPath2(import.meta.url)), ".");
+var packageRoot = resolve4(moduleRoot, "..");
+function vitePluginAstroBuildServer(options) {
+  const integrations = options.integrations ?? [];
+  const resolveFrom = options.resolveFrom ?? process.cwd();
+  const trackedSpecifiers = collectTrackedSpecifiers(integrations);
+  const staticEntrypointRefs = /* @__PURE__ */ new Map();
+  let storybookStaticOutDir = resolve4(resolveFrom, "storybook-static");
+  return {
+    name: "storybook-astro:build-server",
+    apply: "build",
+    enforce: "post",
+    configResolved(config) {
+      storybookStaticOutDir = resolve4(resolveFrom, config.build.outDir ?? "storybook-static");
+    },
+    resolveId(id) {
+      return resolveVirtualBuildModuleId(id);
+    },
+    load(id) {
+      return loadVirtualBuildModule(id);
+    },
+    async buildStart() {
+      await emitBuildEntrypoints({
+        pluginContext: this,
+        integrations,
+        resolveFrom,
+        trackedSpecifiers,
+        staticEntrypointRefs
+      });
+    },
+    async writeBundle(_outputOptions) {
+      const serverOutDir = resolve4(dirname2(storybookStaticOutDir), "storybook-server");
+      const snapshotDirName = "project";
+      const astroStories = await collectAstroStories2(storybookStaticOutDir, resolveFrom);
+      const storyAstroComponentPaths = Array.from(new Set(astroStories.map((story) => story.componentPath)));
+      const componentPathMap = buildComponentPathMap(storyAstroComponentPaths, resolveFrom, snapshotDirName);
+      const storyRulesConfigFilePath = resolveRulesConfigFilePath(options.storyRules, resolveFrom);
+      const trackedModuleMap = buildStaticModuleMap(this, staticEntrypointRefs, /* @__PURE__ */ new Map());
+      const hydratedComponentAssets = await buildHydratedComponentAssets({
+        componentPaths: storyAstroComponentPaths,
+        integrations,
+        resolveFrom,
+        outDir: storybookStaticOutDir
+      });
+      const staticModuleMap = addSnapshotModuleAliases({
+        ...trackedModuleMap,
+        ...hydratedComponentAssets.staticModuleMap
+      }, {
+        resolveFrom,
+        snapshotRoot: resolve4(serverOutDir, snapshotDirName),
+        snapshotDirName
+      });
+      const staticCssMap = hydratedComponentAssets.staticCssMap;
+      await buildAstroServer({
+        integrations,
+        sanitization: options.sanitization,
+        storyRules: options.storyRules,
+        server: options.server,
+        outDir: serverOutDir,
+        snapshotDirName,
+        componentPathMap,
+        staticModuleMap,
+        staticCssMap,
+        trackedSpecifiers: Array.from(trackedSpecifiers),
+        resolveFrom
+      });
+      await copyRuntimeSnapshot({
+        resolveFrom,
+        snapshotRoot: resolve4(serverOutDir, snapshotDirName),
+        snapshotDirName,
+        astroComponents: storyAstroComponentPaths,
+        storyRulesConfigFilePath
+      });
+    }
+  };
+}
+async function buildAstroServer(options) {
+  const buildConfig = {
+    root: resolve4(packageRoot, "src/server"),
+    ssr: {
+      noExternal: /(@astrojs\/.+|react|react-dom)/
+    },
+    build: {
+      ssr: true,
+      outDir: options.outDir,
+      emptyOutDir: true,
+      sourcemap: true,
+      manifest: false,
+      rollupOptions: {
+        input: resolve4(packageRoot, "src/server/index.ts"),
+        treeshake: true
+      }
+    },
+    plugins: [
+      sanitizeConfigPlugin(options.sanitization),
+      serverAuthPlugin(options.server),
+      serverRuntimePlugin({
+        integrations: options.integrations,
+        storyRules: options.storyRules,
+        resolveFrom: options.resolveFrom,
+        snapshotDirName: options.snapshotDirName,
+        componentPathMap: options.componentPathMap,
+        staticModuleMap: options.staticModuleMap,
+        staticCssMap: options.staticCssMap,
+        trackedSpecifiers: options.trackedSpecifiers
+      }),
+      viteAstroContainerRenderersPlugin(options.integrations, {
+        mode: "production",
+        staticModuleMap: options.staticModuleMap
+      })
+    ]
+  };
+  const finalConfig = await mergeWithAstroConfig(
+    buildConfig,
+    options.integrations,
+    options.resolveFrom,
+    "production",
+    "build"
+  );
+  await build(finalConfig);
+}
+function buildComponentPathMap(astroComponents, resolveFrom, snapshotDirName) {
+  return Object.fromEntries(
+    astroComponents.map((componentPath) => [
+      componentPath,
+      buildSnapshotFilePath(resolveFrom, componentPath, snapshotDirName).replace(
+        new RegExp(`^${snapshotDirName}/`),
+        ""
+      )
+    ])
+  );
+}
+async function collectAstroStories2(outDir, resolveFrom) {
+  const indexFile = resolve4(outDir, "index.json");
+  const indexRaw = await import("fs/promises").then(({ readFile: readFile3 }) => readFile3(indexFile, "utf-8"));
+  const indexJson = JSON.parse(indexRaw);
+  return Object.values(indexJson.entries ?? []).filter((entry) => entry.type === "story" && entry.componentPath?.endsWith(".astro")).map((entry) => ({
+    componentPath: entry.componentPath?.startsWith("./") || entry.componentPath?.startsWith("../") ? resolve4(resolveFrom, entry.componentPath) : entry.componentPath
+  })).filter((entry) => Boolean(entry.componentPath));
+}
+async function buildHydratedComponentAssets(options) {
+  const hydratedComponentPaths = Array.from(
+    new Set((await Promise.all(options.componentPaths.map((componentPath) => collectHydratedComponentPaths(componentPath)))).flat())
+  );
+  if (hydratedComponentPaths.length === 0) {
+    return {
+      staticModuleMap: {},
+      staticCssMap: {}
+    };
+  }
+  const clientEntrypoints = Array.from(
+    new Set(
+      options.integrations.map((integration) => integration.renderer.client?.entrypoint).filter((entrypoint) => Boolean(entrypoint))
+    )
+  );
+  const entryNames = Object.fromEntries(
+    [
+      ...hydratedComponentPaths.map((componentPath, index) => [`component-${index}`, componentPath]),
+      ...clientEntrypoints.map((entrypoint, index) => [`renderer-${index}`, entrypoint])
+    ]
+  );
+  const buildConfig = {
+    root: options.resolveFrom,
+    build: {
+      write: false,
+      outDir: options.outDir,
+      emptyOutDir: false,
+      manifest: false,
+      rollupOptions: {
+        input: entryNames,
+        preserveEntrySignatures: "strict",
+        output: {
+          entryFileNames: "_astro/[name]-[hash].js",
+          chunkFileNames: "_astro/[name]-[hash].js",
+          assetFileNames: "_astro/[name]-[hash][extname]"
+        }
+      }
+    }
+  };
+  const finalConfig = await mergeWithAstroConfig(
+    buildConfig,
+    options.integrations,
+    options.resolveFrom,
+    "production",
+    "build"
+  );
+  const buildOutput = await build(finalConfig);
+  const output = Array.isArray(buildOutput) ? buildOutput.flatMap((result) => result.output) : buildOutput.output;
+  const staticModuleMap = {};
+  const staticCssMap = {};
+  for (const item of output) {
+    await writeBuildOutputFile(options.outDir, item);
+    if (item.type !== "chunk" || !item.facadeModuleId) {
+      continue;
+    }
+    const normalizedFacadeId = item.facadeModuleId.replace(/\\/g, "/");
+    const originalInputSpecifier = entryNames[item.name];
+    staticModuleMap[normalizedFacadeId] = `./${item.fileName}`;
+    if (originalInputSpecifier && originalInputSpecifier !== normalizedFacadeId) {
+      staticModuleMap[originalInputSpecifier] = `./${item.fileName}`;
+    }
+    const importedCss = Array.from((item.viteMetadata?.importedCss ?? /* @__PURE__ */ new Set()).values());
+    if (importedCss.length > 0) {
+      staticCssMap[normalizedFacadeId] = importedCss.map((fileName) => `./${fileName}`);
+      if (originalInputSpecifier && originalInputSpecifier !== normalizedFacadeId) {
+        staticCssMap[originalInputSpecifier] = importedCss.map((fileName) => `./${fileName}`);
+      }
+    }
+  }
+  return {
+    staticModuleMap,
+    staticCssMap
+  };
+}
+async function writeBuildOutputFile(outDir, item) {
+  const outputPath = resolve4(outDir, item.fileName);
+  await mkdir3(dirname2(outputPath), { recursive: true });
+  if (item.type === "asset") {
+    await writeFile2(outputPath, item.source);
+    return;
+  }
+  await writeFile2(outputPath, item.code);
+}
+function addSnapshotModuleAliases(staticModuleMap, options) {
+  const mapWithSnapshotPaths = { ...staticModuleMap };
+  for (const [sourcePath, builtPath] of Object.entries(staticModuleMap)) {
+    if (!sourcePath.startsWith("/")) {
+      continue;
+    }
+    const snapshotPath = resolve4(
+      dirname2(options.snapshotRoot),
+      buildSnapshotFilePath(options.resolveFrom, sourcePath, options.snapshotDirName)
+    ).replace(/\\/g, "/");
+    mapWithSnapshotPaths[snapshotPath] = builtPath;
+  }
+  return mapWithSnapshotPaths;
+}
+
+// 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",
+  // 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, storybookOptions) => {
+  const { configType, presets, configDir } = storybookOptions;
+  const frameworkOptions = await presets.apply("frameworkOptions");
+  const options = {
+    ...frameworkOptions,
+    resolveFrom: frameworkOptions.resolveFrom ?? dirname3(configDir)
+  };
+  if (!config.plugins) {
+    config.plugins = [];
+  }
+  const integrations = options.integrations ?? [];
+  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(
+    viteStorybookRendererFallbackPlugin(integrations),
+    viteStorybookAstroRendererPlugin({
+      mode,
+      renderMode,
+      server: options.server
+    }),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vitePluginAstroComponentMarker(),
+    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 = {};
+  }
+  if (!config.resolve.alias) {
+    config.resolve.alias = {};
+  }
+  const aliases = config.resolve.alias;
+  if (!aliases["react"]) {
+    aliases["react"] = "react";
+  }
+  if (!aliases["react-dom"]) {
+    aliases["react-dom"] = "react-dom";
+  }
+  const finalConfig = await mergeWithAstroConfig(
+    config,
+    integrations,
+    options.resolveFrom,
+    mode,
+    command
+  );
+  if (!finalConfig.optimizeDeps) {
+    finalConfig.optimizeDeps = {};
+  }
+  if (!finalConfig.optimizeDeps.exclude) {
+    finalConfig.optimizeDeps.exclude = [];
+  }
+  for (const pkg of [
+    "@astrojs/vue",
+    "@astrojs/vue/client.js",
+    "@astrojs/vue/server.js",
+    "@astrojs/react",
+    "@astrojs/react/client.js",
+    "@astrojs/react/server.js",
+    "@astrojs/preact",
+    "@astrojs/preact/client.js",
+    "@astrojs/preact/server.js"
+  ]) {
+    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");
+  }
+  for (const pkg of ["fsevents", "storybook/internal/preview-api"]) {
+    if (!finalConfig.optimizeDeps.exclude.includes(pkg)) {
+      finalConfig.optimizeDeps.exclude.push(pkg);
+    }
+  }
+  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 = [];
+  }
+  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-H3XZHW6Z.js.map