poveste 0.8.0 → 0.8.2

package/dist/node/bin.js

@@ -7,6 +7,30 @@ const { version } = JSON.parse(fs.readFileSync(resolve(__dirname, '../../package
 process.env.NODE_ENV = process.argv.includes('build') || process.argv.includes('preview') ? 'production' : 'development';
 process.env.HISTOIRE = 'true';
 process.env.POVESTE = 'true';
+// sade does not await an action, so a rejected command was terminated only by
+// Node's default handling of the unhandled rejection it became. That is not the
+// CLI's to rely on: any dependency can install an `unhandledRejection` listener
+// and take it away, which Vike does — and a failed build then ran forever with
+// its error already printed (#405).
+//
+// So failure is reported and exited here, deliberately. `exitCode` alone is not
+// enough — teardown does not get every handle back, and after a failed build a
+// `Timeout` and three `MessagePort`s are still open, so waiting for an empty
+// event loop is what hung in the first place. But exiting on the same tick as
+// the error would truncate it: writes to a piped stderr are asynchronous, and a
+// framed compiler error is long.
+//
+// So both: the exit code is set immediately, and the hard exit is a timer that
+// does not itself hold the loop open. A process with nothing leaked exits on its
+// own, flushing normally; one that leaked is cut loose a moment later, by which
+// time the error has been written.
+function run(command) {
+    return command().then(() => undefined, (error) => {
+        console.error(error);
+        process.exitCode = 1;
+        setTimeout(() => process.exit(1), 500).unref();
+    });
+}
 const program = sade('poveste');
 program.version(version);
 program.command('dev')
@@ -17,14 +41,14 @@ program.command('dev')
     .option('--host [host]', '[string] specify hostname (omit value or pass `0.0.0.0` to expose to all network interfaces)')
     .action(async (options) => {
     const { devCommand } = await import('./commands/dev.js');
-    return devCommand(options);
+    return run(() => devCommand(options));
 });
 program.command('build')
     .describe('build the poveste final app you can deploy')
     .option('-c, --config <file>', `[string] use specified config file`)
     .action(async (options) => {
     const { buildCommand } = await import('./commands/build.js');
-    return buildCommand(options);
+    return run(() => buildCommand(options));
 });
 program.command('preview')
     .describe('preview the built directory')
@@ -33,6 +57,6 @@ program.command('preview')
     .option('--host [host]', '[string] specify hostname (omit value or pass `0.0.0.0` to expose to all network interfaces)')
     .action(async (options) => {
     const { previewCommand } = await import('./commands/preview.js');
-    return previewCommand(options);
+    return run(() => previewCommand(options));
 });
 program.parse(process.argv);

package/dist/node/build.js

@@ -14,6 +14,7 @@ import { startPreview } from './preview.js';
 import { findAllStories } from './stories.js';
 import { chromeCssScopePlugin, entryCssMergerPlugin, userCssScopePlugin, } from './style-isolation/index.js';
 import { applyHeadTransform } from './util/head.js';
+import { wrapLogError } from './util/log.js';
 import { getViteConfigWithPlugins } from './vite.js';
 const PRELOAD_MODULES = [
     'vendor',
@@ -53,195 +54,237 @@ export async function build(ctx) {
         optimizeDeps: { include: [], noDiscovery: true },
     }));
     await server.pluginContainer.buildStart({});
-    const moduleLoader = useModuleLoader({
-        server,
-        throws: true,
-    });
-    const changeViteConfigCallbacks = [];
-    const buildEndCallbacks = [];
-    const previewStoryCallbacks = [];
-    for (const plugin of ctx.config.plugins) {
-        if (plugin.onBuild) {
-            const api = new BuildPluginApi(ctx, plugin, moduleLoader);
-            await plugin.onBuild(api);
-            changeViteConfigCallbacks.push(...api.changeViteConfigCallbacks);
-            buildEndCallbacks.push(...api.buildEndCallbacks);
-            previewStoryCallbacks.push(...api.previewStoryCallbacks);
+    // Everything from here is wrapped so the server is closed on the way out
+    // whichever way that is — it is the other handle that kept a failed build
+    // alive (#405). `serverClosed` keeps the existing order rather than moving the
+    // buildEnd callbacks either side of the close.
+    let serverClosed = false;
+    try {
+        const moduleLoader = useModuleLoader({
+            server,
+            throws: true,
+        });
+        const changeViteConfigCallbacks = [];
+        const buildEndCallbacks = [];
+        const previewStoryCallbacks = [];
+        for (const plugin of ctx.config.plugins) {
+            if (plugin.onBuild) {
+                const api = new BuildPluginApi(ctx, plugin, moduleLoader);
+                await plugin.onBuild(api);
+                changeViteConfigCallbacks.push(...api.changeViteConfigCallbacks);
+                buildEndCallbacks.push(...api.buildEndCallbacks);
+                previewStoryCallbacks.push(...api.previewStoryCallbacks);
+            }
         }
-    }
-    // Collect story data
-    const { executeStoryFile, destroy: destroyCollectStories } = useCollectStories({
-        server,
-        throws: true,
-    }, ctx);
-    await Promise.all(ctx.storyFiles.map(storyFile => executeStoryFile(storyFile)));
-    await destroyCollectStories();
-    const storyCount = ctx.storyFiles.reduce((sum, file) => sum + (file.story?.variants.length ? 1 : 0), 0);
-    const variantCount = ctx.storyFiles.reduce((sum, file) => sum + (file.story?.variants.length ?? 0), 0);
-    const emptyStoryCount = ctx.storyFiles.length - storyCount;
-    const { viteConfig: buildViteConfigRaw } = await getViteConfigWithPlugins(false, ctx);
-    const buildViteConfig = mergeViteConfig(buildViteConfigRaw, {
-        mode: 'development',
-        build: {
-            lib: false,
-            rollupOptions: {
-                input: [
-                    join(APP_PATH, 'bundle-main.js'),
-                    join(APP_PATH, 'bundle-sandbox.js'),
-                ],
-                plugins: [
-                    {
-                        name: 'poveste-build-rollup-options-override',
-                        enforce: 'post',
-                        options(options) {
-                            // Don't externalize
-                            options.external = [];
-                        },
+        // Collect story data
+        const { executeStoryFile, destroy: destroyCollectStories } = useCollectStories({
+            server,
+            throws: true,
+        }, ctx);
+        // `throws: true`, so one bad story rejects here. Without the `finally` the
+        // teardown below never ran, eleven worker threads stayed alive, and the process
+        // hung instead of failing — the error was printed and then nothing (#405).
+        try {
+            await Promise.all(ctx.storyFiles.map(storyFile => executeStoryFile(storyFile)));
+        }
+        finally {
+            // Logged, not thrown: a teardown that rejects would replace the error that
+            // caused the teardown, which is the failure this whole change is about.
+            // Same wrapper the dev path uses for these exact calls (server.ts).
+            await wrapLogError('destroyCollectStories', () => destroyCollectStories());
+        }
+        const storyCount = ctx.storyFiles.reduce((sum, file) => sum + (file.story?.variants.length ? 1 : 0), 0);
+        const variantCount = ctx.storyFiles.reduce((sum, file) => sum + (file.story?.variants.length ?? 0), 0);
+        const emptyStoryCount = ctx.storyFiles.length - storyCount;
+        const { viteConfig: buildViteConfigRaw } = await getViteConfigWithPlugins(false, ctx);
+        const buildViteConfig = mergeViteConfig(buildViteConfigRaw, {
+            mode: 'development',
+            build: {
+                lib: false,
+                rollupOptions: {
+                    // Named, not an array. With an array the bundler derives `[name]` from the
+                    // path, and `APP_PATH` is absolute — so any framework whose `entryFileNames`
+                    // refuses a path-shaped `[name]` fails the build outright (#369, and
+                    // histoire-dev/histoire#802 before it). The keys make `[name]` the key.
+                    input: {
+                        'bundle-main': join(APP_PATH, 'bundle-main.js'),
+                        'bundle-sandbox': join(APP_PATH, 'bundle-sandbox.js'),
                     },
-                ],
-            },
-        },
-    });
-    // For @vite/plugin-vue: Always put our vite server
-    // Disable template inlining
-    // (so that we no longer need defineExpose)
-    // Nuxt: replaces the Nuxt vite dev server
-    buildViteConfig.plugins.push({
-        name: 'poveste-vue-plugin-override',
-        config(config) {
-            const vuePlugin = config.plugins.find((p) => p.name === 'vite:vue');
-            if (vuePlugin) {
-                // @ts-expect-error vue plugin use function form
-                const original = vuePlugin.configureServer.bind(vuePlugin);
-                vuePlugin.configureServer = () => {
-                    original({
-                        ...server,
-                        config: {
-                            ...server.config,
-                            server: {
-                                ...server.config.server,
-                                hmr: false,
+                    plugins: [
+                        {
+                            name: 'poveste-build-rollup-options-override',
+                            enforce: 'post',
+                            options(options) {
+                                // Don't externalize
+                                options.external = [];
                             },
                         },
-                    });
-                };
-                // @ts-expect-error vue plugin use function form
-                vuePlugin.configureServer(server);
-            }
-        },
-    });
-    buildViteConfig.plugins.push({
-        name: 'poveste-build-config-override',
-        enforce: 'post',
-        config(config) {
-            // Don't externalize
-            config.build.rollupOptions.external = [];
-            // Force chunk strategy
-            config.build.rollupOptions.output = {
-                manualChunks(id) {
-                    // Vite's runtime helpers (`\0vite/preload-helper.js` and friends) are
-                    // virtual modules, so the node_modules routing below never sees them
-                    // and their placement is left to the bundler — which parked
-                    // `__vitePreload` inside the 10 MB `highlighter` chunk. Every chunk
-                    // importing the helper then statically imported the whole highlighter,
-                    // and the sandbox was back to evaluating it once per grid cell (#197),
-                    // undoing exactly what `APP_ONLY_VENDORS` is for. Pin them somewhere
-                    // harmless instead of leaving the choice to chunking heuristics.
-                    if (id.replace(/^\0/, '').startsWith('vite/')) {
-                        return 'app-runtime';
-                    }
-                    if (!id.includes('@poveste/app') && id.includes('node_modules')) {
-                        if (APP_ONLY_VENDORS.some(test => test.test(id))) {
-                            return 'highlighter';
+                    ],
+                },
+            },
+        });
+        // For @vite/plugin-vue: Always put our vite server
+        // Disable template inlining
+        // (so that we no longer need defineExpose)
+        // Nuxt: replaces the Nuxt vite dev server
+        buildViteConfig.plugins.push({
+            name: 'poveste-vue-plugin-override',
+            config(config) {
+                const vuePlugin = config.plugins.find((p) => p.name === 'vite:vue');
+                if (vuePlugin) {
+                    // @ts-expect-error vue plugin use function form
+                    const original = vuePlugin.configureServer.bind(vuePlugin);
+                    vuePlugin.configureServer = () => {
+                        original({
+                            ...server,
+                            config: {
+                                ...server.config,
+                                server: {
+                                    ...server.config.server,
+                                    hmr: false,
+                                },
+                            },
+                        });
+                    };
+                    // @ts-expect-error vue plugin use function form
+                    vuePlugin.configureServer(server);
+                }
+            },
+        });
+        buildViteConfig.plugins.push({
+            name: 'poveste-build-config-override',
+            enforce: 'post',
+            config(config) {
+                // Don't externalize
+                config.build.rollupOptions.external = [];
+                // Force chunk strategy
+                config.build.rollupOptions.output = {
+                    manualChunks(id) {
+                        // Vite's runtime helpers (`\0vite/preload-helper.js` and friends) are
+                        // virtual modules, so the node_modules routing below never sees them
+                        // and their placement is left to the bundler — which parked
+                        // `__vitePreload` inside the 10 MB `highlighter` chunk. Every chunk
+                        // importing the helper then statically imported the whole highlighter,
+                        // and the sandbox was back to evaluating it once per grid cell (#197),
+                        // undoing exactly what `APP_ONLY_VENDORS` is for. Pin them somewhere
+                        // harmless instead of leaving the choice to chunking heuristics.
+                        if (id.replace(/^\0/, '').startsWith('vite/')) {
+                            return 'app-runtime';
                         }
-                        for (const test of ctx.config.build?.excludeFromVendorsChunk ?? []) {
-                            if ((typeof test === 'string' && id.includes(test)) || (test instanceof RegExp && test.test(id))) {
-                                // Excluded from vendor chunk
-                                return;
+                        if (!id.includes('@poveste/app') && id.includes('node_modules')) {
+                            if (APP_ONLY_VENDORS.some(test => test.test(id))) {
+                                return 'highlighter';
+                            }
+                            for (const test of ctx.config.build?.excludeFromVendorsChunk ?? []) {
+                                if ((typeof test === 'string' && id.includes(test)) || (test instanceof RegExp && test.test(id))) {
+                                    // Excluded from vendor chunk
+                                    return;
+                                }
                             }
+                            return 'vendor';
+                        }
+                    },
+                };
+                // A framework that declares Vite environments gives each one its own
+                // `build.outDir`, and that wins over the top-level value for the environment's
+                // output — so the book was written to the framework's directory (Vike: `dist/client`)
+                // while poveste kept looking in `outDir` (#369). Only the client environment
+                // builds the book. Where no framework declared environments there is nothing to
+                // override, and where one did this puts the book back where poveste reads it.
+                if (config.environments?.client?.build) {
+                    config.environments.client.build.outDir = ctx.config.outDir;
+                }
+                // Force vite build options
+                Object.assign(config.build, {
+                    outDir: ctx.config.outDir,
+                    emptyOutDir: true,
+                    // Re-merged per-entry by entry-css-merger.
+                    cssCodeSplit: true,
+                    minify: false,
+                    // Don't build in SSR mode
+                    ssr: false,
+                });
+                config.define.__HST_COLLECT__ = false;
+            },
+        });
+        const isolate = ctx.config.isolateStyles !== false;
+        buildViteConfig.plugins.push(userCssScopePlugin({ enabled: isolate }));
+        buildViteConfig.plugins.push(chromeCssScopePlugin({ enabled: isolate }));
+        buildViteConfig.plugins.push(entryCssMergerPlugin({ isolateStyles: isolate }));
+        for (const cb of changeViteConfigCallbacks) {
+            console.log('vite config hook', cb);
+            await cb(buildViteConfig);
+        }
+        const results = await viteBuild(buildViteConfig);
+        const result = Array.isArray(results) ? results[0] : results;
+        function findEntryCss(entryName) {
+            return result.output.find(o => o.type === 'asset' && o.fileName === `${entryName}.css`);
+        }
+        const mainStyleOutput = findEntryCss('bundle-main')
+            ?? result.output.find(o => o.name === 'style.css' && o.type === 'asset');
+        const sandboxStyleOutput = findEntryCss('bundle-sandbox') ?? mainStyleOutput;
+        // Preload
+        const preloadOutputs = result.output.filter(o => PRELOAD_MODULES.includes(o.name) && o.type === 'chunk');
+        const preloadHtml = generateScriptLinks(preloadOutputs.map(o => o.fileName), 'preload', ctx);
+        // Prefetch
+        const prefetchOutputs = result.output.filter(o => PREFETCHED_MODULES.includes(o.name) && o.type === 'chunk');
+        const prefetchHtml = generateScriptLinks(prefetchOutputs.map(o => o.fileName), 'prefetch', ctx);
+        // Index
+        const indexOutput = result.output.find(o => o.name === 'bundle-main' && o.type === 'chunk');
+        let indexHtml = generateEntryHtml(indexOutput.fileName, mainStyleOutput.fileName, {
+            HEAD: `${preloadHtml}${prefetchHtml}`,
+        }, ctx);
+        indexHtml = await applyHeadTransform(indexHtml, ctx.config.head);
+        await writeFile('index.html', indexHtml, ctx);
+        // Sandbox
+        const sandboxOutput = result.output.find(o => o.name === 'bundle-sandbox' && o.type === 'chunk');
+        let sandboxHtml = generateEntryHtml(sandboxOutput.fileName, sandboxStyleOutput.fileName, {}, ctx);
+        sandboxHtml = await applyHeadTransform(sandboxHtml, ctx.config.head);
+        await writeFile('__sandbox.html', sandboxHtml, ctx);
+        await writeFile('poveste.json', JSON.stringify(getSerializedStoryData(ctx), null, 2), ctx);
+        const duration = performance.now() - startTime;
+        if (emptyStoryCount) {
+            console.warn(pc.yellow(`⚠️  ${emptyStoryCount} empty story file${emptyStoryCount === 1 ? '' : 's'}`));
+        }
+        console.log(pc.green(`✅ Built ${storyCount} stor${storyCount === 1 ? 'y' : 'ies'} (${variantCount} variant${variantCount === 1 ? '' : 's'}) in ${Math.round(duration / 1000 * 100) / 100}s`));
+        // Render
+        if (previewStoryCallbacks.length) {
+            const { baseUrl, close } = await startPreview({}, ctx);
+            try {
+                for (const storyFile of ctx.storyFiles) {
+                    const story = storyFile.story;
+                    for (const variant of story.variants) {
+                        const query = new URLSearchParams();
+                        query.append('storyId', story.id);
+                        query.append('variantId', variant.id);
+                        const url = `${baseUrl}__sandbox.html?${query.toString()}`;
+                        for (const fn of previewStoryCallbacks) {
+                            await fn({
+                                file: storyFile.path,
+                                story,
+                                variant,
+                                url,
+                            });
                         }
-                        return 'vendor';
                     }
-                },
-            };
-            // Force vite build options
-            Object.assign(config.build, {
-                outDir: ctx.config.outDir,
-                emptyOutDir: true,
-                // Re-merged per-entry by entry-css-merger.
-                cssCodeSplit: true,
-                minify: false,
-                // Don't build in SSR mode
-                ssr: false,
-            });
-            config.define.__HST_COLLECT__ = false;
-        },
-    });
-    const isolate = ctx.config.isolateStyles !== false;
-    buildViteConfig.plugins.push(userCssScopePlugin({ enabled: isolate }));
-    buildViteConfig.plugins.push(chromeCssScopePlugin({ enabled: isolate }));
-    buildViteConfig.plugins.push(entryCssMergerPlugin({ isolateStyles: isolate }));
-    for (const cb of changeViteConfigCallbacks) {
-        console.log('vite config hook', cb);
-        await cb(buildViteConfig);
-    }
-    const results = await viteBuild(buildViteConfig);
-    const result = Array.isArray(results) ? results[0] : results;
-    function findEntryCss(entryName) {
-        return result.output.find(o => o.type === 'asset' && o.fileName === `${entryName}.css`);
-    }
-    const mainStyleOutput = findEntryCss('bundle-main')
-        ?? result.output.find(o => o.name === 'style.css' && o.type === 'asset');
-    const sandboxStyleOutput = findEntryCss('bundle-sandbox') ?? mainStyleOutput;
-    // Preload
-    const preloadOutputs = result.output.filter(o => PRELOAD_MODULES.includes(o.name) && o.type === 'chunk');
-    const preloadHtml = generateScriptLinks(preloadOutputs.map(o => o.fileName), 'preload', ctx);
-    // Prefetch
-    const prefetchOutputs = result.output.filter(o => PREFETCHED_MODULES.includes(o.name) && o.type === 'chunk');
-    const prefetchHtml = generateScriptLinks(prefetchOutputs.map(o => o.fileName), 'prefetch', ctx);
-    // Index
-    const indexOutput = result.output.find(o => o.name === 'bundle-main' && o.type === 'chunk');
-    let indexHtml = generateEntryHtml(indexOutput.fileName, mainStyleOutput.fileName, {
-        HEAD: `${preloadHtml}${prefetchHtml}`,
-    }, ctx);
-    indexHtml = await applyHeadTransform(indexHtml, ctx.config.head);
-    await writeFile('index.html', indexHtml, ctx);
-    // Sandbox
-    const sandboxOutput = result.output.find(o => o.name === 'bundle-sandbox' && o.type === 'chunk');
-    let sandboxHtml = generateEntryHtml(sandboxOutput.fileName, sandboxStyleOutput.fileName, {}, ctx);
-    sandboxHtml = await applyHeadTransform(sandboxHtml, ctx.config.head);
-    await writeFile('__sandbox.html', sandboxHtml, ctx);
-    await writeFile('poveste.json', JSON.stringify(getSerializedStoryData(ctx), null, 2), ctx);
-    const duration = performance.now() - startTime;
-    if (emptyStoryCount) {
-        console.warn(pc.yellow(`⚠️  ${emptyStoryCount} empty story file${emptyStoryCount === 1 ? '' : 's'}`));
-    }
-    console.log(pc.green(`✅ Built ${storyCount} stor${storyCount === 1 ? 'y' : 'ies'} (${variantCount} variant${variantCount === 1 ? '' : 's'}) in ${Math.round(duration / 1000 * 100) / 100}s`));
-    // Render
-    if (previewStoryCallbacks.length) {
-        const { baseUrl, close } = await startPreview({}, ctx);
-        for (const storyFile of ctx.storyFiles) {
-            const story = storyFile.story;
-            for (const variant of story.variants) {
-                const query = new URLSearchParams();
-                query.append('storyId', story.id);
-                query.append('variantId', variant.id);
-                const url = `${baseUrl}__sandbox.html?${query.toString()}`;
-                for (const fn of previewStoryCallbacks) {
-                    await fn({
-                        file: storyFile.path,
-                        story,
-                        variant,
-                        url,
-                    });
                 }
             }
+            finally {
+                // A screenshot or percy callback that throws would otherwise leave this
+                // server bound — the same leak as the two above, one level down.
+                await wrapLogError('startPreview.close', () => close());
+            }
+        }
+        await server.close();
+        serverClosed = true;
+        for (const fn of buildEndCallbacks) {
+            await fn();
         }
-        await close();
     }
-    await server.close();
-    for (const fn of buildEndCallbacks) {
-        await fn();
+    finally {
+        if (!serverClosed) {
+            await wrapLogError('server.close', () => server.close());
+        }
     }
 }
 function generateBaseHtml(head, body, ctx) {

package/dist/node/collect/define-globals.d.ts

@@ -0,0 +1 @@
+export declare function globalsFromDefine(define: Record<string, unknown> | undefined): Record<string, unknown>;

package/dist/node/collect/define-globals.js

@@ -0,0 +1,42 @@
+// Story collection runs in a Node worker. Externalised dependencies are loaded by
+// native Node ESM, so Vite never applies `define` to them — and a bare compile-time
+// feature flag is just an undefined identifier there. vue-i18n reading
+// `__VUE_PROD_DEVTOOLS__` was the reported case (#284); anything with build-time
+// flags fails the same way.
+//
+// The fix is to give the collection environment the same values a real build would
+// substitute, taken from Vite's own resolved `define` rather than a list of library
+// names this package would have to keep current.
+// Only `__FLAG__`-shaped keys are seeded. Every flag this exists for follows that
+// convention — `__VUE_OPTIONS_API__`, `__VUE_PROD_DEVTOOLS__`, `__VUE_I18N_LEGACY_API__`,
+// `__INTLIFY_PROD_DEVTOOLS__` — and narrow is the right failure here. A browser-targeted
+// config shimming a Node global (`define: { process: '{"env":{}}' }` is a real shape)
+// would otherwise replace the collection worker's own `process`, surfacing far from the
+// config that caused it. Refusing to evaluate arbitrary expressions while letting
+// arbitrary identifiers overwrite the runtime would be a guard in name only.
+// `process.env.NODE_ENV` and friends fail the same test, being member expressions.
+const FEATURE_FLAG = /^__[A-Z0-9_]+__$/;
+// Vite `define` values are JS expression *source*. A plugin-injected flag arrives
+// already parsed (`false`), while a user's `define: { X: 'false' }` arrives as the
+// string `"false"` — and seeding that string would make the flag *truthy*, silently
+// inverting it. So strings are parsed as literals, and anything that is not a literal
+// is skipped: evaluating arbitrary expressions here is not something this should do.
+export function globalsFromDefine(define) {
+    const globals = {};
+    for (const [key, value] of Object.entries(define ?? {})) {
+        if (!FEATURE_FLAG.test(key)) {
+            continue;
+        }
+        if (typeof value !== 'string') {
+            globals[key] = value;
+            continue;
+        }
+        try {
+            globals[key] = JSON.parse(value);
+        }
+        catch {
+            // Not a literal — leave it undefined rather than guess at it.
+        }
+    }
+    return globals;
+}

package/dist/node/collect/index.js

@@ -8,6 +8,7 @@ import { ViteNodeServer } from 'vite-node/server';
 import { TEMP_PATH } from '../alias.js';
 import { createPath } from '../tree.js';
 import { slash } from '../util/fs.js';
+import { globalsFromDefine } from './define-globals.js';
 export function useCollectStories(options, ctx) {
     const { server, mainServer } = options;
     const node = new ViteNodeServer(server, {
@@ -34,6 +35,8 @@ export function useCollectStories(options, ctx) {
         },
         transformMode: ctx.config.viteNodeTransformMode,
     });
+    // Same values a real build substitutes, so externalised deps see their flags.
+    const defineGlobals = globalsFromDefine(server.config.define);
     const maxThreads = ctx.config.collectMaxThreads ?? cpus().length;
     const threadsCount = ctx.mode === 'dev'
         ? Math.max(Math.min(maxThreads, Math.floor(cpus().length / 2)), 1)
@@ -83,6 +86,7 @@ export function useCollectStories(options, ctx) {
                 base: server.config.base,
                 storyFile,
                 port: workerPort,
+                defineGlobals,
             };
             const { storyData } = await threadPool.run(payload, {
                 transferList: [

package/dist/node/collect/worker.d.ts

@@ -5,6 +5,7 @@ export interface Payload {
     base: string;
     port: MessagePort;
     storyFile: ServerStoryFile;
+    defineGlobals?: Record<string, unknown>;
 }
 export interface ReturnData {
     storyData: ServerStory[];

package/dist/node/collect/worker.js

@@ -22,6 +22,11 @@ parentPort.on('message', (message) => {
 export default async (payload) => {
     const startTime = performance.now();
     process.env.HST_COLLECT = 'true';
+    // Before any module runs: an externalised dep reads these at import time.
+    for (const [key, value] of Object.entries(payload.defineGlobals ?? {})) {
+        ;
+        globalThis[key] = value;
+    }
     _rpc = createBirpc({}, {
         post: data => payload.port.postMessage(data),
         on: data => payload.port.on('message', data),

package/dist/node/optimize-entries.d.ts

@@ -0,0 +1,3 @@
+import type { PovesteConfig } from '@poveste/shared';
+export declare function optimizeEntries(config: Pick<PovesteConfig, 'storyMatch' | 'storyIgnored' | 'setupFile'>, root: string, isServer: boolean): string[];
+export declare function setupFileEntry(setupFile: PovesteConfig['setupFile'], isServer: boolean): string | undefined;

package/dist/node/optimize-entries.js

@@ -0,0 +1,48 @@
+import { globbySync } from 'globby';
+import { resolve } from 'pathe';
+// Vite pre-bundles whatever its dependency scanner reaches by crawling
+// `optimizeDeps.entries`. Two things in a book route around that scan:
+//
+//   - stories are loaded dynamically, never statically imported from the app entry
+//   - the setup file is reached through `virtual:$poveste-setup`, an id the scanner
+//     cannot resolve
+//
+// So a dependency used only in a story or a setup file is discovered on first
+// navigation instead, and Vite answers with `optimized dependencies changed.
+// reloading` — a full reload that drops the preview's scroll and state (#282).
+//
+// The stories are resolved here rather than handed over as patterns, because
+// `storyIgnored` cannot be expressed as entry patterns. Vite globs the whole entries
+// array together, so a `!**/dist/**` negation would also match `APP_PATH`, which *is*
+// `<poveste-app>/dist` — silently dropping the app's own scan entries. Resolving the
+// files gives `storyIgnored` its exact meaning and cannot touch anything else.
+export function optimizeEntries(config, root, isServer) {
+    // Same call the collector makes, so the scanner sees exactly the story set the
+    // book will load — no stale `dist/` copies the book itself excludes.
+    const stories = globbySync(config.storyMatch, {
+        cwd: root,
+        ignore: config.storyIgnored,
+        absolute: true,
+    });
+    const setup = setupFileEntry(config.setupFile, isServer);
+    return setup ? [...stories, resolve(root, setup)] : stories;
+}
+// Mirrors how `virtual/vite-plugin.ts` picks the file. These are documented
+// root-relative and written with a leading slash (`/src/setup.ts`), which
+// `resolve` would read as absolute.
+export function setupFileEntry(setupFile, isServer) {
+    if (!setupFile) {
+        return undefined;
+    }
+    let file;
+    if (typeof setupFile === 'string') {
+        file = setupFile;
+    }
+    else if (isServer && 'server' in setupFile) {
+        file = setupFile.server;
+    }
+    else if (!isServer && 'browser' in setupFile) {
+        file = setupFile.browser;
+    }
+    return file ? file.replace(/^\/+/, '') : undefined;
+}

package/dist/node/vite.js

@@ -5,6 +5,7 @@ import { dirname, join, relative } from 'pathe';
 import { loadConfigFromFile as loadViteConfigFromFile, mergeConfig as mergeViteConfig, searchForWorkspaceRoot, } from 'vite';
 import { APP_PATH, TEMP_PATH } from './alias.js';
 import { createMarkdownPlugins } from './markdown.js';
+import { optimizeEntries } from './optimize-entries.js';
 import { notifyStoryChange } from './stories.js';
 import { chromeCssScopePlugin, globalStylesPlugin, userCssScopePlugin, } from './style-isolation/index.js';
 import { applyHeadTransform } from './util/head.js';
@@ -124,6 +125,9 @@ export async function getViteConfigWithPlugins(isServer, ctx) {
                     entries: [
                         `${APP_PATH}/bundle-main.js`,
                         `${APP_PATH}/bundle-sandbox.js`,
+                        // Without these the scanner never sees a story or the setup file, and
+                        // their deps cost a full reload when they turn up later (#282).
+                        ...optimizeEntries(ctx.config, ctx.root, isServer),
                     ],
                     include: optimizeDeps([
                         'shiki',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poveste",
   "type": "module",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Interactive component playgrounds for Vue, Svelte and Nuxt — a maintained, drop-in successor to histoire",
   "author": {
     "name": "Sorin Gitlan"
@@ -98,10 +98,10 @@
     "sirv": "^3.0.0",
     "unhead": "^3.1.0",
     "vite-node": "^6.0.0",
-    "@poveste/controls": "^0.8.0",
-    "@poveste/app": "^0.8.0",
-    "@poveste/shared": "^0.8.0",
-    "@poveste/vendors": "^0.8.0"
+    "@poveste/app": "^0.8.2",
+    "@poveste/controls": "^0.8.2",
+    "@poveste/shared": "^0.8.2",
+    "@poveste/vendors": "^0.8.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",