@storybook-astro/framework 1.0.3 → 1.1.1

package/src/vitePluginAstroBuildServer.ts

@@ -0,0 +1,289 @@
+import type { Dirent } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build, type Rollup } from 'vite';
+import type { FrameworkOptions } from './types.ts';
+import { mergeWithAstroConfig } from './vitePluginAstro.ts';
+import { viteAstroContainerRenderersPlugin } from './viteAstroContainerRenderersPlugin.ts';
+import { astroFilesVirtualModulePlugin } from './vite/astroFilesVirtualModulePlugin.ts';
+import { storybookAstroStoryRulesConfigVirtualModulePlugin } from './vite/storybookAstroRulesConfigVirtualModulePlugin.ts';
+import { storybookAstroSanitizationConfigVirtualModulePlugin } from './vite/storybookAstroSanitizationConfigVirtualModulePlugin.ts';
+import { storybookAstroServerAuthConfigVirtualModulePlugin } from './vite/storybookAstroServerAuthConfigVirtualModulePlugin.ts';
+
+const moduleRoot = resolve(dirname(fileURLToPath(import.meta.url)), '.');
+// packageRoot works regardless of whether this file is running from src/ or dist/
+const packageRoot = resolve(moduleRoot, '..');
+
+export function vitePluginAstroBuildServer(options: FrameworkOptions) {
+  const integrations = options.integrations ?? [];
+  const resolveFrom = options.resolveFrom ?? process.cwd();
+  const storiesMap = new Map<string, Set<string>>();
+  const trackedSpecifiers = collectTrackedSpecifiers(integrations);
+  const staticEntrypointRefs = new Map<string, string>();
+  const componentEntrypointRefs = new Map<string, string>();
+  let storybookStaticOutDir = resolve(resolveFrom, 'storybook-static');
+
+  return {
+    name: 'storybook-astro:build-server',
+    apply: 'build',
+    enforce: 'post',
+
+    configResolved(config: { build: { outDir?: string } }) {
+      storybookStaticOutDir = resolve(resolveFrom, config.build.outDir ?? 'storybook-static');
+    },
+
+    resolveId(id: string, importer?: string) {
+      if (id.endsWith('.astro') && importer) {
+        const absoluteAstroPath = resolve(dirname(importer), id);
+
+        if (!storiesMap.has(absoluteAstroPath)) {
+          storiesMap.set(absoluteAstroPath, 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: string) {
+      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 encodedSpecifier = id.replace('\0virtual:astro-component-module/', '');
+        const specifier = decodeURIComponent(encodedSpecifier);
+
+        return [`export { default } from '${specifier}';`, `export * from '${specifier}';`].join('\n');
+      }
+    },
+
+    async buildStart(this: Rollup.PluginContext) {
+      integrations.forEach((integration) => {
+        const entrypoint = integration.renderer.client?.entrypoint;
+
+        if (entrypoint) {
+          this.addWatchFile(entrypoint);
+        }
+      });
+
+      trackedSpecifiers.forEach((specifier) => {
+        const fileReferenceId = this.emitFile({
+          type: 'chunk',
+          id: toStaticVirtualId(specifier)
+        });
+
+        staticEntrypointRefs.set(specifier, fileReferenceId);
+      });
+
+      const srcRoot = resolve(resolveFrom, 'src/components');
+      const specifiers = await collectHydratableSourceModules(srcRoot);
+
+      specifiers.forEach((specifier) => {
+        const fileReferenceId = this.emitFile({
+          type: 'chunk',
+          id: toComponentVirtualId(specifier)
+        });
+
+        componentEntrypointRefs.set(specifier, fileReferenceId);
+      });
+    },
+
+    async writeBundle(this: Rollup.PluginContext) {
+      const astroComponents = Array.from(storiesMap.keys());
+      const staticModuleMap = buildStaticModuleMap(
+        this,
+        staticEntrypointRefs,
+        componentEntrypointRefs
+      );
+      const serverOutDir = resolve(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: {
+  astroComponents: string[];
+  integrations: FrameworkOptions['integrations'];
+  sanitization?: FrameworkOptions['sanitization'];
+  storyRules?: FrameworkOptions['storyRules'];
+  server?: FrameworkOptions['server'];
+  outDir: string;
+  staticModuleMap: Record<string, string>;
+  resolveFrom: string;
+}) {
+  const buildConfig = {
+    root: resolve(packageRoot, 'src/server'),
+    ssr: {
+      noExternal: /(@astrojs\/.+|react|react-dom)/
+    },
+    build: {
+      ssr: true,
+      outDir: options.outDir,
+      emptyOutDir: true,
+      sourcemap: true,
+      manifest: false,
+      rollupOptions: {
+        input: resolve(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 collectTrackedSpecifiers(integrations: FrameworkOptions['integrations']) {
+  const specifiers = new Set<string>(['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: Rollup.PluginContext,
+  staticEntrypointRefs: Map<string, string>,
+  componentEntrypointRefs: Map<string, string>
+) {
+  const map: Record<string, string> = {};
+
+  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 toStaticVirtualId(specifier: string) {
+  return `virtual:astro-static-module/${encodeURIComponent(specifier)}`;
+}
+
+function toComponentVirtualId(specifier: string) {
+  return `virtual:astro-component-module/${encodeURIComponent(specifier)}`;
+}
+
+function isClientEntrypoint(specifier: string) {
+  return specifier.startsWith('@astrojs/') && specifier.endsWith('/client.js');
+}
+
+function toPublicPath(fileName: string) {
+  return `./${fileName}`;
+}
+
+async function collectHydratableSourceModules(srcRoot: string): Promise<string[]> {
+  const modules: string[] = [];
+
+  async function walk(directory: string) {
+    let entries: Dirent[];
+
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    await Promise.all(
+      entries.map(async (entry) => {
+        const absolutePath = resolve(directory, entry.name);
+
+        if (entry.isDirectory()) {
+          await walk(absolutePath);
+
+          return;
+        }
+
+        if (!entry.isFile()) {
+          return;
+        }
+
+        const normalizedPath = absolutePath.replace(/\\/g, '/');
+
+        if (!isHydratableSourceFile(normalizedPath)) {
+          return;
+        }
+
+        if (isNonHydratableSourceFile(normalizedPath)) {
+          return;
+        }
+
+        modules.push(normalizedPath);
+      })
+    );
+  }
+
+  await walk(srcRoot);
+
+  return modules;
+}
+
+function isHydratableSourceFile(input: string) {
+  return /\.(jsx|tsx|vue|svelte|js|ts)$/.test(input);
+}
+
+function isNonHydratableSourceFile(input: string) {
+  return /\.stories\.[jt]sx?$|\.stories\.vue$|\.stories\.svelte$|\.(spec|test)\.[jt]sx?$/.test(
+    input
+  );
+}

package/src/vitePluginAstroIntegrationOptsFallback.ts

@@ -0,0 +1,25 @@
+import type { Plugin } from 'vite';
+
+const OPTS_STUB = 'export default {}';
+
+const VIRTUAL_IDS = ['astro:react:opts', 'astro:preact:opts'];
+
+export function vitePluginAstroIntegrationOptsFallback(): Plugin {
+  const resolvedIds = new Map(VIRTUAL_IDS.map((id) => [id, `\0${id}`]));
+  const resolvedIdSet = new Set(resolvedIds.values());
+
+  return {
+    name: 'storybook-astro-integration-opts-fallback',
+    enforce: 'pre',
+
+    resolveId(id) {
+      return resolvedIds.get(id);
+    },
+
+    load(id) {
+      if (resolvedIdSet.has(id)) {
+        return { code: OPTS_STUB };
+      }
+    }
+  };
+}

package/src/vitePluginAstroToolbarFallback.ts

@@ -0,0 +1,38 @@
+import type { Plugin } from 'vite';
+
+const TOOLBAR_INTERNAL_STUB = `
+export const loadDevToolbarApps = async () => [];
+`;
+
+/**
+ * Provides a fallback stub for Astro's dev toolbar virtual module.
+ *
+ * Astro's `astro/dist/runtime/client/dev-toolbar/entrypoint.js` imports
+ * from `astro:toolbar:internal`, a virtual module normally provided by
+ * Astro's own `vite-plugin-dev-toolbar` Vite plugin. In the Storybook
+ * context that plugin is not active, causing esbuild to fail during
+ * dependency optimisation when it encounters the unresolvable import.
+ *
+ * Storybook doesn't use Astro's dev toolbar, so a no-op stub is safe.
+ */
+export function vitePluginAstroToolbarFallback(): Plugin {
+  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 };
+      }
+    }
+  };
+}

package/src/viteStorybookAstroMiddlewarePlugin.ts

@@ -1,12 +1,14 @@
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
-import { createServer, type PluginOption, type ViteDevServer } from 'vite';
+import type { ServerResponse } from 'node:http';
+import { createServer, createLogger, type Connect, type PluginOption, type ViteDevServer } from 'vite';
 import type { RenderRequestMessage, RenderResponseMessage } from '@storybook-astro/renderer/types';
 import type { FrameworkOptions } from './types.ts';
 import type { Integration } from './integrations/index.ts';
 import { importAstroConfig } from './importAstroConfig.ts';
 import { viteAstroContainerRenderersPlugin } from './viteAstroContainerRenderersPlugin.ts';
 import { vitePluginAstroFontsFallback } from './vitePluginAstroFontsFallback.ts';
+import { vitePluginAstroIntegrationOptsFallback } from './vitePluginAstroIntegrationOptsFallback.ts';
 import { vitePluginAstroVueFallback } from './vitePluginAstroVueFallback.ts';
 import { vitePluginAstroRoutesFallback } from './vitePluginAstroRoutesFallback.ts';
 import { ssrLoadModuleWithFsFallback } from './lib/ssr-load-module-with-fs-fallback.ts';
@@ -22,7 +24,7 @@ export async function vitePluginStorybookAstroMiddleware(options: FrameworkOptio
   const vitePlugin = {
     name: 'storybook-astro-middleware-plugin',
     async configureServer(server) {
-      viteServer = await createViteServer(options.integrations, resolveFrom);
+      viteServer = await createViteServer(options.integrations ?? [], resolveFrom);
       const storyRulesConfigFilePath = resolveRulesConfigFilePath(options.storyRules, resolveFrom);
 
       const filePath = fileURLToPath(new URL('./middleware', import.meta.url));
@@ -31,7 +33,6 @@ export async function vitePluginStorybookAstroMiddleware(options: FrameworkOptio
       });
 
       const createHandler = () => middleware.handlerFactory(options.integrations ?? [], {
-        mode: 'development',
         sanitization: options.sanitization,
         rulesConfigFilePath: storyRulesConfigFilePath,
         resolveRulesConfigModule: () =>
@@ -84,15 +85,15 @@ export async function vitePluginStorybookAstroMiddleware(options: FrameworkOptio
   // Create asset serving plugin (only active in dev when viteServer exists)
   const assetServingPlugin = {
     name: 'storybook-astro-assets',
-    configureServer(server) {
-      server.middlewares.use('/_image', (req, res, next) => {
+    configureServer(server: ViteDevServer) {
+      server.middlewares.use('/_image', (req: Connect.IncomingMessage, res: ServerResponse, next: Connect.NextFunction) => {
         if (!viteServer) {
           next();
 
           return;
         }
         // Forward the request to the Astro vite server
-        viteServer.middlewares.handle(req, res, (err) => {
+        viteServer.middlewares.handle(req, res, (err?: unknown) => {
           if (err) {
             console.error('Asset serving error:', err);
             next();
@@ -122,8 +123,33 @@ export async function vitePluginStorybookAstroMiddleware(options: FrameworkOptio
   };
 }
 
+/**
+ * Creates a Vite logger that silences known benign warnings emitted by Astro's
+ * Vite plugin in the SSR server context:
+ * - "Missing pages directory" — Storybook and test contexts have no src/pages.
+ * - "points to missing source files" — Sourcemap gaps in the `entities` package.
+ */
+function createSsrServerLogger() {
+  const logger = createLogger();
+  const originalWarn = logger.warn.bind(logger);
+
+  logger.warn = (msg, options) => {
+    if (
+      msg.includes('Missing pages directory') ||
+      msg.includes('points to missing source files') ||
+      msg.includes('Failed to load source map for')
+    ) {
+      return;
+    }
+
+    originalWarn(msg, options);
+  };
+
+  return logger;
+}
+
 export async function createViteServer(integrations: Integration[], resolveFrom = process.cwd()) {
-  const { getViteConfig } = await importAstroConfig(resolveFrom);
+  const { getViteConfig, passthroughImageService } = await importAstroConfig(resolveFrom);
   const safeIntegrations = integrations ?? [];
   const projectAstroResolutionPlugin = createProjectAstroResolutionPlugin(resolveFrom);
 
@@ -133,17 +159,23 @@ export async function createViteServer(integrations: Integration[], resolveFrom
       configFile: false,
       integrations: await Promise.all(
         safeIntegrations.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: 'development', command: 'serve' });
 
   const viteServer = await createServer({
     configFile: false,
     ...config,
+    customLogger: createSsrServerLogger(),
     plugins: [
       projectAstroResolutionPlugin,
       // Fallbacks must come first to intercept before Astro's plugins
       vitePluginAstroFontsFallback(),
+      vitePluginAstroIntegrationOptsFallback(),
       vitePluginAstroVueFallback(),
       vitePluginAstroRoutesFallback(),
       ...(config.plugins?.filter(Boolean) ?? []),

package/src/viteStorybookAstroRendererPlugin.ts

@@ -0,0 +1,45 @@
+import type { RenderMode, ServerBuildOptions } from './types.ts';
+import { createVirtualModulePlugin } from './vite/createVirtualModulePlugin.ts';
+
+const packageName = '@storybook-astro/framework';
+
+export function viteStorybookAstroRendererPlugin(options: {
+  mode: 'development' | 'production';
+  renderMode?: RenderMode;
+  server?: ServerBuildOptions;
+}) {
+  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');
+    }
+  });
+}

package/src/vitest/config.ts

@@ -1,4 +1,6 @@
 import { defineConfig as defineVitestConfig } from 'vitest/config';
+import { createLogger } from 'vite';
+import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import type { InlineConfig, PluginOption } from 'vite';
 import type { Integration } from '../integrations/base.ts';
@@ -7,9 +9,35 @@ import { vitePluginAstroComponentMarker } from '../vitePluginAstroComponentMarke
 import { registerTestingIntegrationsForRoot } from '../testing/integration-config.ts';
 import { cjsInteropPlugin, vitestPatchForSolidJs } from './vite-plugins.ts';
 
+/**
+ * Creates a Vite logger that suppresses known benign warnings in the test context:
+ * - "Missing pages directory" — Astro warns when no src/pages exists, but component
+ *   tests don't use pages so this is always safe to ignore.
+ * - "points to missing source files" — Sourcemap warnings from the `entities` package
+ *   which ships without source files. Not actionable.
+ */
+function createTestLogger() {
+  const logger = createLogger();
+  const originalWarn = logger.warn.bind(logger);
+
+  logger.warn = (msg, options) => {
+    if (
+      msg.includes('Missing pages directory') ||
+      msg.includes('points to missing source files') ||
+      msg.includes('Failed to load source map for')
+    ) {
+      return;
+    }
+
+    originalWarn(msg, options);
+  };
+
+  return logger;
+}
+
 // Type definition omits 'test' to allow Vitest-specific config options
 // Vite 8 type definitions conflict with Vitest config when used in monorepo
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Vitest config requires any type for test option
+ 
 export type TestingDefineConfig = Omit<InlineConfig, 'plugins' | 'test'> & {
   integrations?: Integration[];
   plugins?: PluginOption[];
@@ -51,7 +79,13 @@ export function defineConfig(options: TestingDefineConfig) {
 
   registerTestingIntegrationsForRoot(root, integrations);
 
-  const globalSetupFilePath = fileURLToPath(new URL('./global-setup.ts', import.meta.url));
+  // In the workspace, import.meta.url points to src/vitest/config.ts so global-setup.ts exists.
+  // In a compiled tarball install, import.meta.url points to dist/vitest/config.js so we fall
+  // back to global-setup.js which is the tsup-compiled output.
+  const globalSetupTsPath = fileURLToPath(new URL('./global-setup.ts', import.meta.url));
+  const globalSetupFilePath = existsSync(globalSetupTsPath)
+    ? globalSetupTsPath
+    : fileURLToPath(new URL('./global-setup.js', import.meta.url));
   const testConfig = {
     ...rest.test,
     globalSetup: normalizeGlobalSetup(rest.test?.globalSetup, globalSetupFilePath)
@@ -59,7 +93,7 @@ export function defineConfig(options: TestingDefineConfig) {
 
   // Cast to any to work around Vite 8 type conflicts in monorepo environments
   // where multiple Vite versions exist in node_modules
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Type conflict with Vite 8 in monorepo
+   
   const vitestConfig = defineVitestConfig({
     ...rest,
     root,
@@ -87,9 +121,16 @@ export function defineConfig(options: TestingDefineConfig) {
       })
     );
 
+  const testLogger = createTestLogger();
+
   return async ({ mode: viteMode, command }: { mode: string; command: 'build' | 'serve' }) => {
     const astroConfigFactory = await astroConfigFactoryPromise;
+    const config = await astroConfigFactory({ mode: viteMode, command });
+
+    // Inject the logger — this overrides any logger Astro may have set,
+    // which is intentional since we only filter benign test-context noise.
+    config.customLogger = testLogger;
 
-    return astroConfigFactory({ mode: viteMode, command });
+    return config;
   };
 }

package/src/vitest/global-setup.ts

@@ -3,7 +3,50 @@ import {
   startTestingRendererDaemon
 } from '../testing/renderer-daemon.ts';
 
+/**
+ * Patterns for warnings that are always benign in the test context and should
+ * be silenced so they don't pollute test output.
+ *
+ * - "Missing pages directory" — Astro emits this when the project root has no
+ *   src/pages directory. Component tests never have pages.
+ * - "points to missing source files" — Sourcemap gaps in the `entities` package;
+ *   a third-party packaging issue, not actionable.
+ */
+const SUPPRESSED_WARNING_PATTERNS = [
+  'Missing pages directory',
+  'points to missing source files',
+  'Failed to load source map for'
+];
+
+function shouldSuppress(chunk: Buffer | string): boolean {
+  const msg = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+
+  return SUPPRESSED_WARNING_PATTERNS.some((pattern) => msg.includes(pattern));
+}
+
 export default async function globalSetup() {
+  // Intercept stderr before starting the daemon so that Astro's own logger
+  // (which bypasses Vite's customLogger) doesn't leak benign noise into output.
+  const originalWrite = process.stderr.write.bind(process.stderr);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (process.stderr as any).write = function (
+    chunk: Buffer | string,
+    encodingOrCb?: BufferEncoding | ((err?: Error | null) => void),
+    cb?: (err?: Error | null) => void
+  ): boolean {
+    if (shouldSuppress(chunk)) {
+      const done = typeof encodingOrCb === 'function' ? encodingOrCb : cb;
+
+      done?.();
+
+      return true;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (originalWrite as any)(chunk, encodingOrCb, cb);
+  };
+
   const daemon = await startTestingRendererDaemon();
 
   // Workers discover the shared renderer via env instead of creating their own SSR stack.
@@ -12,5 +55,7 @@ export default async function globalSetup() {
   return async () => {
     await daemon.close();
     delete process.env[TESTING_RENDERER_DAEMON_URL_ENV];
+    // Restore stderr so post-teardown output is unaffected.
+    process.stderr.write = originalWrite;
   };
 }