poveste 0.17.2 → 0.18.1

package/README.md

@@ -20,7 +20,7 @@ pnpm i -D poveste @poveste/plugin-nuxt     # Nuxt 4
 pnpm i -D poveste @poveste/plugin-quasar   # Quasar
 ```
 
-> **Installed an older version than you expected?** For about a day after a release, pnpm installs the previous one — `(x.y.z is available)`, no error. That is pnpm's release-age cooldown, not a broken publish. Use `npm`, wait it out, or pass `--config.minimum-release-age=0` (kebab-case — pnpm 12 silently ignores the camelCase spelling). Asking for the exact version does not help: pnpm 12 refuses one inside the window too.
+> **Installed an older version than you expected?** For about a day after a release, pnpm installs the previous one with no error and no hint, and for a plugin that's new in that release, its empty `0.0.1` placeholder. That's pnpm's release-age cooldown, not a broken publish. `package.json` keeps the old `^x.y.z`, so waiting doesn't fix it: install again with `npm`, with `--config.minimum-release-age=0` (kebab-case: pnpm 12.4 ignores the camelCase spelling), or with exact versions.
 
 Then create a `poveste.config.ts` in your project root:
 
@@ -47,10 +47,12 @@ Run `npx poveste --help` for the full list of options.
 
 ## Requirements
 
-Node `>=24.15.0` and Vite `^8.0.0`. See
+Node `>=22.22.2` and Vite `^8.0.0`. See
 [supported versions](https://poveste.dev/guide/getting-started#supported-versions) for
 what proves each range.
 
+On Node 24, use 24.15 or later: Poveste's DOM dependency (jsdom) accepts `^22.22.2 || ^24.15.0 || >=26`.
+
 ## Links
 
 - [Documentation](https://poveste.dev)

package/dist/node/collect/error.js

@@ -1,3 +1,4 @@
+import { isError } from '../util/is-error.js';
 /*
  * Structured clone keeps an `Error`'s `name`, `message` and `stack` and drops every
  * own property beyond them, so the code frame a Vite transform error puts on `frame`
@@ -19,7 +20,7 @@ function isSerialized(value) {
  * story may legitimately throw, and it should arrive as the data it is.
  */
 function errorLike(value) {
-    if (Error.isError(value)) {
+    if (isError(value)) {
         return true;
     }
     if (typeof value !== 'object' || value === null) {

package/dist/node/collect/index.js

@@ -3,6 +3,7 @@ import path, { relative } from 'pathe';
 import pc from 'picocolors';
 import { TEMP_PATH } from '../alias.js';
 import { createPath } from '../tree.js';
+import { escapeRegExp } from '../util/escape-regexp.js';
 import { slash } from '../util/fs.js';
 import { globalsFromDefine } from './define-globals.js';
 import { createModuleServer } from './module-server.js';
@@ -24,7 +25,7 @@ export function useCollectStories(options, ctx) {
             // @TODO temporary fix for https://github.com/histoire-dev/histoire/issues/409
             /vite\w*\/dist\/client\/(client|env).mjs/,
             ...ctx.config.viteNodeInlineDeps ?? [],
-            new RegExp(RegExp.escape(path.resolve(TEMP_PATH, 'plugins'))),
+            new RegExp(escapeRegExp(path.resolve(TEMP_PATH, 'plugins'))),
         ],
         transformMode: ctx.config.viteNodeTransformMode,
     });

package/dist/node/context.js

@@ -1,7 +1,7 @@
-import { resolveConfig as resolveViteConfig } from 'vite';
+import { loadConfigFromFile as loadViteConfigFromFile, resolveConfig as resolveViteConfig } from 'vite';
 import { processConfig, resolveConfig } from './config.js';
 import { viteCommand, viteMode } from './util/vite-mode.js';
-import { mergePovesteViteConfig } from './vite.js';
+import { mergePovesteViteConfig, withoutIgnoredPlugins } from './vite.js';
 export async function createContext(options) {
     const config = await resolveConfig(process.cwd(), options.mode, options.configFile);
     const command = viteCommand(options.mode);
@@ -9,7 +9,15 @@ export async function createContext(options) {
     // `'development'` whatever the command, and `base` from this resolution is
     // what the hand-written index.html uses while the bundle uses the build's.
     // A user config setting `base` by mode would otherwise disagree with itself.
-    const viteConfig = await resolveViteConfig({}, command, viteMode(options.mode));
+    // Through `viteIgnorePlugins`, as the dev server and the build are: an ignored
+    // plugin's `config` hook still runs in a resolution that skips it, and SvelteKit's
+    // sets a relative `base` here, which index.html then carries (#1200).
+    const userViteConfig = await loadViteConfigFromFile({ command, mode: viteMode(options.mode) });
+    const viteConfig = await resolveViteConfig({
+        ...userViteConfig?.config,
+        configFile: false,
+        plugins: await withoutIgnoredPlugins(userViteConfig?.config.plugins, config.viteIgnorePlugins),
+    }, command, viteMode(options.mode));
     const supportPlugins = config.plugins.flatMap(p => p.supportPlugin ? [p.supportPlugin] : []);
     const partial = {
         root: viteConfig.root,

package/dist/node/dom/env.d.ts

@@ -2,6 +2,7 @@ export declare function createDomEnv(): {
     window: Window & typeof globalThis;
     destroy: () => void;
     pristineKeys: Set<string>;
+    storages: Storage[];
 };
 /** Returns a reused environment to the state a fresh one would have been in. */
-export declare function resetDomEnv(env: Pick<ReturnType<typeof createDomEnv>, 'window' | 'pristineKeys'>): void;
+export declare function resetDomEnv(env: Pick<ReturnType<typeof createDomEnv>, 'window' | 'pristineKeys' | 'storages'>): void;

package/dist/node/dom/env.js

@@ -1,4 +1,5 @@
 import { JSDOM, VirtualConsole, } from 'jsdom';
+import { isError } from '../util/is-error.js';
 import { populateGlobal } from './util.js';
 // jsdom error types — not exported by jsdom.
 const JSDOM_ERROR_CSS_PARSING = 'css-parsing';
@@ -26,7 +27,7 @@ function createVirtualConsole() {
             // `Error.isError` and not `instanceof`: the cause was constructed inside
             // jsdom's realm, where `instanceof Error` is false and the stack — the
             // only part that says which line threw — is discarded (#1093).
-            globalThis.console.error((Error.isError(err.cause) ? err.cause.stack : undefined) ?? err.message);
+            globalThis.console.error((isError(err.cause) ? err.cause.stack : undefined) ?? err.message);
         }
         else {
             globalThis.console.error(err.message);
@@ -43,12 +44,31 @@ export function createDomEnv() {
         includeNodeLocations: false,
         contentType: 'text/html',
     });
+    const storageNames = ['localStorage', 'sessionStorage'];
+    // Before `populateGlobal`, which installs jsdom's own on older Node.
+    const storageDescriptors = storageNames.map(name => Object.getOwnPropertyDescriptor(globalThis, name));
     const { keys, originals } = populateGlobal(globalThis, dom.window, { bindFunctions: true });
+    // From Node 25 the global names are Node's experimental Web Storage, so
+    // `populateGlobal` leaves them, and every read warns without
+    // `--localstorage-file`: from a story during collection, and from the reset
+    // below (#1175). jsdom's take their place, as they already did on older Node.
+    // Descriptors rather than values, because reading Node's is what warns.
+    const storages = storageNames.map(name => dom.window[name]);
+    storageNames.forEach((name, index) => {
+        Object.defineProperty(globalThis, name, { configurable: true, enumerable: true, writable: true, value: storages[index] });
+    });
     function destroy() {
         keys.forEach(key => Reflect.deleteProperty(globalThis, key));
         originals.forEach((v, k) => {
             Reflect.set(globalThis, k, v);
         });
+        storageNames.forEach((name, index) => {
+            const descriptor = storageDescriptors[index];
+            if (descriptor)
+                Object.defineProperty(globalThis, name, descriptor);
+            else
+                Reflect.deleteProperty(globalThis, name);
+        });
     }
     window.ResizeObserver = window.ResizeObserver || class ResizeObserver {
         disconnect() { }
@@ -105,6 +125,7 @@ export function createDomEnv() {
         // `populateGlobal` does `global.window = global`, so `window` here is
         // `globalThis` — one surface, not two.
         pristineKeys: new Set(Object.keys(globalThis)),
+        storages,
     };
 }
 /** Returns a reused environment to the state a fresh one would have been in. */
@@ -119,14 +140,8 @@ export function resetDomEnv(env) {
     }
     doc.head?.replaceChildren();
     doc.body?.replaceChildren();
-    try {
-        // Only present when the key was proxied onto the global, which varies by
-        // node version.
-        env.window.localStorage?.clear();
-        env.window.sessionStorage?.clear();
-    }
-    catch {
-        // Unavailable for some jsdom urls.
+    for (const storage of env.storages) {
+        storage.clear();
     }
     // Additions only: the modules that installed the rest are cached, not re-run.
     for (const key of Object.keys(globalThis)) {

package/dist/node/server.js

@@ -131,6 +131,17 @@ async function startServer(ctx, options, onOpen, close) {
     });
     let collecting = false;
     let didAllStoriesYet = false;
+    const updateFor = (url, timestamp) => ({
+        type: 'update',
+        updates: [
+            {
+                type: 'js-update',
+                acceptedPath: url,
+                path: url,
+                timestamp,
+            },
+        ],
+    });
     // Invalidate modules
     const invalidateModule = (id) => {
         const mod = server.moduleGraph.getModuleById(id);
@@ -141,18 +152,33 @@ async function startServer(ctx, options, onOpen, close) {
         // Send HMR update
         const timestamp = Date.now();
         mod.lastHMRTimestamp = timestamp;
-        server.ws.send({
-            type: 'update',
-            updates: [
-                {
-                    type: 'js-update',
-                    acceptedPath: mod.url,
-                    path: mod.url,
-                    timestamp,
-                },
-            ],
-        });
+        server.ws.send(updateFor(mod.url, timestamp));
+    };
+    // Bumped before the list is invalidated, so the copy a client loads next
+    // carries the generation it reflects.
+    const invalidateStoryList = () => {
+        VirtualFiles.storiesGeneration.set(ctx, (VirtualFiles.storiesGeneration.get(ctx) ?? 0) + 1);
+        invalidateModule(VirtualFiles.RESOLVED_STORIES_ID);
+        invalidateModule(VirtualFiles.RESOLVED_SEARCH_TITLE_DATA_ID);
     };
+    // The update and `poveste:all-stories-loaded` reach only a page that has
+    // already evaluated the list and registered for them, and neither is
+    // replayed. A page that loaded the list mid-collection and was still loading
+    // when collection ended kept that partial list until a reload (#1218). By the
+    // time it mounts it is listening, so it is sent what it missed.
+    server.ws.on('poveste:mount', (data, client) => {
+        if (!didAllStoriesYet || data?.generation === (VirtualFiles.storiesGeneration.get(ctx) ?? 0)) {
+            return;
+        }
+        const timestamp = Date.now();
+        for (const id of [VirtualFiles.RESOLVED_STORIES_ID, VirtualFiles.RESOLVED_SEARCH_TITLE_DATA_ID]) {
+            const mod = server.moduleGraph.getModuleById(id);
+            if (mod) {
+                client.send(updateFor(mod.url, timestamp));
+            }
+        }
+        client.send('poveste:all-stories-loaded', {});
+    });
     onOpen('onStoryChange', onStoryChange(async (changedFile) => {
         if (changedFile && !didAllStoriesYet) {
             return;
@@ -227,16 +253,14 @@ async function startServer(ctx, options, onOpen, close) {
             return;
         }
         console.log(`Collect stories end ${pc.bold(pc.blue(Math.round(performance.now() - time)))}ms`);
-        invalidateModule(VirtualFiles.RESOLVED_STORIES_ID);
-        invalidateModule(VirtualFiles.RESOLVED_SEARCH_TITLE_DATA_ID);
+        invalidateStoryList();
         collecting = false;
         if (queued) {
             await collect();
         }
     }
     onOpen('onStoryListChange', onStoryListChange(() => {
-        invalidateModule(VirtualFiles.RESOLVED_STORIES_ID);
-        invalidateModule(VirtualFiles.RESOLVED_SEARCH_TITLE_DATA_ID);
+        invalidateStoryList();
     }));
     onOpen('onMarkdownListChange', onMarkdownListChange(() => {
         invalidateModule(VirtualFiles.RESOLVED_MARKDOWN_FILES);

package/dist/node/util/escape-regexp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Escapes a string so a `RegExp` built from it matches that string literally.
+ *
+ * Not `RegExp.escape`: Node 22, inside the supported range since #1226, does not
+ * have it, and TypeScript's `ESNext` lib types it anyway, so the compiler says
+ * nothing when it is used.
+ */
+export declare function escapeRegExp(value: string): string;

package/dist/node/util/escape-regexp.js

@@ -0,0 +1,10 @@
+/**
+ * Escapes a string so a `RegExp` built from it matches that string literally.
+ *
+ * Not `RegExp.escape`: Node 22, inside the supported range since #1226, does not
+ * have it, and TypeScript's `ESNext` lib types it anyway, so the compiler says
+ * nothing when it is used.
+ */
+export function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/node/util/is-error.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `Error.isError` where the Node has it, which is from 24; Node 22, inside the
+ * supported range since #1226, does not. The fallback gives the same answer for
+ * what these call sites see: an error from another realm, jsdom's included, still
+ * reports `[object Error]`, and jsdom's `DOMException` fails both.
+ */
+export declare function isError(value: unknown): value is Error;

package/dist/node/util/is-error.js

@@ -0,0 +1,10 @@
+const native = Error.isError;
+/**
+ * `Error.isError` where the Node has it, which is from 24; Node 22, inside the
+ * supported range since #1226, does not. The fallback gives the same answer for
+ * what these call sites see: an error from another realm, jsdom's included, still
+ * reports `[object Error]`, and jsdom's `DOMException` fails both.
+ */
+export function isError(value) {
+    return native ? native(value) : Object.prototype.toString.call(value) === '[object Error]';
+}

package/dist/node/vendors.d.ts

@@ -1,8 +1,16 @@
+import type { Plugin as VitePlugin } from 'vite';
 /**
  * Resolves `specifier` as Node would from `from`, to a real path, or `undefined`
  * when nothing answers.
  */
 export type Resolver = (specifier: string, from: string) => string | undefined;
+/**
+ * Finds the package by walking `node_modules` up from `from`, then lets Node resolve
+ * the subpath from inside it, through its `exports`. Not `require.resolve` from `from`:
+ * Node folds NODE_PATH into every lookup, even with `paths`, and pnpm's bin shims
+ * point it at the whole store, so a Svelte book run through `poveste` "had" a Vue of
+ * its own and the chrome was collapsed onto a Vue Vite could not find (#1201).
+ */
 export declare const nodeResolver: Resolver;
 export interface VendoredAlias {
     /** The bare package the alias points at, `vue`. */
@@ -54,8 +62,8 @@ export declare function satisfiesCaret(version: string | undefined, range: strin
  * and making the chrome's pinned copies authoritative for a project's own story code
  * is a larger change than this defect asks for.
  *
- * Empty when the project has no Vue of its own, when the two already resolve to one
- * file, or when the project's Vue does not satisfy the range vendors pins — in each
+ * Empty when the project has no Vue of its own, or when the project's Vue does not
+ * satisfy the range vendors pins — in each
  * case the vendored copy is what the chrome should keep. Refusing on anything it
  * cannot read with certainty is deliberate: the failure of this function is a chrome
  * that keeps a Vue it can certainly run, and the failure of guessing is a chrome
@@ -71,4 +79,36 @@ export declare function satisfiesCaret(version: string | undefined, range: strin
 export declare function collapseVendoredVue(options: {
     root: string;
     resolve?: Resolver;
+    /** Where `@poveste/vendors` is resolved from: Poveste's own install unless a test says otherwise. */
+    vendorsFrom?: string;
 }): Record<string, string>;
+/**
+ * Resolves `@poveste/vendors` from Poveste's own install, wherever it is imported.
+ *
+ * `@poveste/vendors` is excluded from pre-bundling, so the pre-bundled
+ * `@poveste/controls` keeps bare imports of it. Vite resolves an optimized entry's
+ * imports from the package's real location, but a shared chunk of one has no real
+ * location and resolves from `node_modules/.pvt-vite/deps` under the project. Since
+ * #593 split the controls into chunks, that only worked where npm or Yarn had
+ * hoisted `@poveste/vendors` to the project's `node_modules`. pnpm doesn't, and
+ * `poveste dev` rendered a blank page (#1201).
+ */
+export declare function vendorsFromPoveste(): VitePlugin;
+/**
+ * The chrome's vendored packages, as nested pre-bundle specifiers, for a book with no
+ * Vue of its own (Svelte, Solid, React).
+ *
+ * There the collapse has no project Vue to point at, and under pnpm `poveste-vue`
+ * and the `vue` that `poveste-vue-router` imports are one file in the store. Vite
+ * pre-bundled the first and served the second raw: one file, two module instances,
+ * and a book that rendered no story. Pre-bundling every vendored package together,
+ * reached through Poveste's own install, puts their Vue in one shared chunk (#1201).
+ *
+ * Empty wherever the collapse applies, or when the chain cannot be resolved from
+ * the project, where Vite would only warn about an include it cannot find.
+ */
+export declare function chromePrebundles(options: {
+    root: string;
+    resolve?: Resolver;
+    vendorsFrom?: string;
+}): string[];

package/dist/node/vendors.js

@@ -1,15 +1,37 @@
-import { readFileSync, realpathSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { join } from 'pathe';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'pathe';
+// A file of this package's own, to resolve from.
+const POVESTE_FILE = fileURLToPath(import.meta.url);
+function packageName(specifier) {
+    const parts = specifier.split('/');
+    return specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+}
+/**
+ * Finds the package by walking `node_modules` up from `from`, then lets Node resolve
+ * the subpath from inside it, through its `exports`. Not `require.resolve` from `from`:
+ * Node folds NODE_PATH into every lookup, even with `paths`, and pnpm's bin shims
+ * point it at the whole store, so a Svelte book run through `poveste` "had" a Vue of
+ * its own and the chrome was collapsed onto a Vue Vite could not find (#1201).
+ */
 export const nodeResolver = (specifier, from) => {
-    try {
-        // `createRequire` resolves relative to the *dirname* of what it is given, so a
-        // directory has to be named as a file inside it or every lookup starts one
-        // level too high.
-        return realpathSync(createRequire(join(from, 'noop.js')).resolve(specifier));
-    }
-    catch {
-        return undefined;
+    const name = packageName(specifier);
+    for (let dir = from;; dir = dirname(dir)) {
+        const candidate = join(dir, 'node_modules', name);
+        if (existsSync(join(candidate, 'package.json'))) {
+            try {
+                // From a file inside the package, whose own `node_modules` parent is the
+                // first place Node looks, so the lookup ends here before NODE_PATH.
+                return realpathSync(createRequire(join(candidate, 'package.json')).resolve(specifier));
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (dirname(dir) === dir) {
+            return undefined;
+        }
     }
 };
 /**
@@ -92,8 +114,8 @@ export function satisfiesCaret(version, range) {
  * and making the chrome's pinned copies authoritative for a project's own story code
  * is a larger change than this defect asks for.
  *
- * Empty when the project has no Vue of its own, when the two already resolve to one
- * file, or when the project's Vue does not satisfy the range vendors pins — in each
+ * Empty when the project has no Vue of its own, or when the project's Vue does not
+ * satisfy the range vendors pins — in each
  * case the vendored copy is what the chrome should keep. Refusing on anything it
  * cannot read with certainty is deliberate: the failure of this function is a chrome
  * that keeps a Vue it can certainly run, and the failure of guessing is a chrome
@@ -109,12 +131,13 @@ export function satisfiesCaret(version, range) {
 export function collapseVendoredVue(options) {
     const { root } = options;
     const resolve = options.resolve ?? nodeResolver;
-    // From the vendors directory, not from the project: that is where the import
-    // happens, and an isolated `node_modules` layout makes `poveste-vue` invisible
-    // from the project root while the chrome resolves it perfectly well.
+    // Vendors from Poveste's own install, and `poveste-vue` from the vendors directory:
+    // that is where each import happens. An isolated `node_modules` layout, pnpm's,
+    // puts neither at the project root, so resolving vendors from there found nothing,
+    // nothing was collapsed, and a pnpm book had two Vues (#1201).
     // Through an exported subpath: vendors' `exports` map does not list
     // `./package.json`, so resolving that name directly fails.
-    const vendorsEntry = resolve('@poveste/vendors/vue', root);
+    const vendorsEntry = resolve('@poveste/vendors/vue', options.vendorsFrom ?? dirname(POVESTE_FILE));
     const vendorsDir = vendorsEntry ? join(vendorsEntry, '..') : undefined;
     if (!vendorsDir) {
         return {};
@@ -127,7 +150,10 @@ export function collapseVendoredVue(options) {
     const [installedAs, { range }] = vueAlias;
     const vendored = resolve(installedAs, vendorsDir);
     const project = resolve('vue', root);
-    if (!vendored || !project || vendored === project) {
+    // Even when they are one file, as pnpm makes them: Vite keys a pre-bundled dependency
+    // by the name it is imported under, so `poveste-vue` was served raw beside the
+    // pre-bundled `vue` — one file, two module instances, and no story (#1201).
+    if (!vendored || !project) {
         return {};
     }
     if (!satisfiesCaret(versionOf('vue/package.json', resolve, root), range)) {
@@ -155,3 +181,52 @@ function readJson(file) {
         return undefined;
     }
 }
+/**
+ * Resolves `@poveste/vendors` from Poveste's own install, wherever it is imported.
+ *
+ * `@poveste/vendors` is excluded from pre-bundling, so the pre-bundled
+ * `@poveste/controls` keeps bare imports of it. Vite resolves an optimized entry's
+ * imports from the package's real location, but a shared chunk of one has no real
+ * location and resolves from `node_modules/.pvt-vite/deps` under the project. Since
+ * #593 split the controls into chunks, that only worked where npm or Yarn had
+ * hoisted `@poveste/vendors` to the project's `node_modules`. pnpm doesn't, and
+ * `poveste dev` rendered a blank page (#1201).
+ */
+export function vendorsFromPoveste() {
+    return {
+        name: 'poveste:vendors-from-poveste',
+        enforce: 'pre',
+        resolveId(source, _importer, options) {
+            if (source !== '@poveste/vendors' && !source.startsWith('@poveste/vendors/')) {
+                return null;
+            }
+            return this.resolve(source, POVESTE_FILE, { ...options, skipSelf: true });
+        },
+    };
+}
+/**
+ * The chrome's vendored packages, as nested pre-bundle specifiers, for a book with no
+ * Vue of its own (Svelte, Solid, React).
+ *
+ * There the collapse has no project Vue to point at, and under pnpm `poveste-vue`
+ * and the `vue` that `poveste-vue-router` imports are one file in the store. Vite
+ * pre-bundled the first and served the second raw: one file, two module instances,
+ * and a book that rendered no story. Pre-bundling every vendored package together,
+ * reached through Poveste's own install, puts their Vue in one shared chunk (#1201).
+ *
+ * Empty wherever the collapse applies, or when the chain cannot be resolved from
+ * the project, where Vite would only warn about an include it cannot find.
+ */
+export function chromePrebundles(options) {
+    const { root } = options;
+    const resolve = options.resolve ?? nodeResolver;
+    if (resolve('vue', root) || !resolve('poveste/package.json', root)) {
+        return [];
+    }
+    const vendorsEntry = resolve('@poveste/vendors/vue', options.vendorsFrom ?? dirname(POVESTE_FILE));
+    if (!vendorsEntry) {
+        return [];
+    }
+    const aliases = vendoredAliases(readJson(join(vendorsEntry, '..', 'package.json'))?.dependencies);
+    return Object.keys(aliases).map(installedAs => `poveste > @poveste/vendors > ${installedAs}`);
+}

package/dist/node/virtual/resolved-stories.d.ts

@@ -1,2 +1,8 @@
 import type { Context } from '../context.js';
+/**
+ * How many times the story list has changed since the server started, per book.
+ * A client that loaded the list before a change, and missed the update that
+ * announced it, is told so when it mounts (#1218).
+ */
+export declare const storiesGeneration: WeakMap<Context, number>;
 export declare function resolvedStories(ctx: Context): string;

package/dist/node/virtual/resolved-stories.js

@@ -1,5 +1,11 @@
 import { makeTree } from '../tree.js';
 import { jsString } from './codegen.js';
+/**
+ * How many times the story list has changed since the server started, per book.
+ * A client that loaded the list before a change, and missed the update that
+ * announced it, is told so when it mounts (#1218).
+ */
+export const storiesGeneration = new WeakMap();
 export function resolvedStories(ctx) {
     const resolvedStories = ctx.storyFiles.filter(s => !!s.story);
     const files = resolvedStories.map((file, index) => {
@@ -26,6 +32,7 @@ ${resolvedStories.map((file, index) => {
     }).filter(Boolean).join('\n')}
 export let files = [${files.map(file => `{${JSON.stringify(file).slice(1, -1)}, component: Comp${file.index}, source: () => import(${jsString(`virtual:story-source:${file.story.id}`)})}`).join(',\n')}]
 export let tree = ${JSON.stringify(makeTree(ctx.config, resolvedStories))}
+export let generation = ${storiesGeneration.get(ctx) ?? 0}
 const handlers = []
 export function onUpdate (cb) {
   handlers.push(cb)
@@ -34,6 +41,7 @@ if (import.meta.hot) {
   import.meta.hot.accept(newModule => {
     files = newModule.files
     tree = newModule.tree
+    generation = newModule.generation
     handlers.forEach(h => {
       h(newModule.files, newModule.tree)
       newModule.onUpdate(h)

package/dist/node/vite.d.ts

@@ -1,5 +1,11 @@
-import type { InlineConfig } from 'vite';
+import type { PovesteConfig } from '@poveste/shared';
+import type { InlineConfig, PluginOption } from 'vite';
 import type { Context } from './context.js';
+/**
+ * The user's plugins, flattened one level as Vite's own options are, without the
+ * ones `viteIgnorePlugins` names.
+ */
+export declare function withoutIgnoredPlugins(plugins: PluginOption[] | undefined, ignored: PovesteConfig['viteIgnorePlugins']): Promise<PluginOption[]>;
 export declare function mergePovesteViteConfig(viteConfig: InlineConfig, ctx: Pick<Context, 'config' | 'mode'>): Promise<InlineConfig>;
 export interface ViteConfigWithPlugins {
     viteConfig: InlineConfig;

package/dist/node/vite.js

@@ -8,11 +8,29 @@ 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 { escapeRegExp } from './util/escape-regexp.js';
 import { applyHeadTransform } from './util/head.js';
 import { viteCommand, viteMode } from './util/vite-mode.js';
-import { collapseVendoredVue } from './vendors.js';
+import { chromePrebundles, collapseVendoredVue, vendorsFromPoveste } from './vendors.js';
 import { createVirtualFilesPlugin } from './virtual/vite-plugin.js';
 const require = createRequire(import.meta.url);
+/**
+ * The user's plugins, flattened one level as Vite's own options are, without the
+ * ones `viteIgnorePlugins` names.
+ */
+export async function withoutIgnoredPlugins(plugins, ignored) {
+    const flat = [];
+    for (const pluginOption of plugins ?? []) {
+        const resolvedPluginOption = await pluginOption;
+        if (Array.isArray(resolvedPluginOption)) {
+            flat.push(...await Promise.all(resolvedPluginOption));
+        }
+        else {
+            flat.push(resolvedPluginOption);
+        }
+    }
+    return flat.filter(plugin => plugin && !('name' in plugin && ignored?.includes(plugin.name)));
+}
 export async function mergePovesteViteConfig(viteConfig, ctx) {
     if (ctx.config.vite) {
         const command = viteCommand(ctx.mode);
@@ -26,24 +44,7 @@ export async function mergePovesteViteConfig(viteConfig, ctx) {
             viteConfig = mergeViteConfig(viteConfig, overrides);
         }
     }
-    let flatPlugins = [];
-    if (viteConfig.plugins) {
-        for (const pluginOption of viteConfig.plugins) {
-            const resolvedPluginOption = await pluginOption;
-            if (Array.isArray(resolvedPluginOption)) {
-                flatPlugins.push(...await Promise.all(resolvedPluginOption));
-            }
-            else {
-                flatPlugins.push(resolvedPluginOption);
-            }
-        }
-        flatPlugins = flatPlugins.filter(Boolean);
-    }
-    const ignoredPlugins = ctx.config.viteIgnorePlugins;
-    if (ignoredPlugins) {
-        flatPlugins = flatPlugins.filter(plugin => !(plugin && 'name' in plugin && ignoredPlugins.includes(plugin.name)));
-    }
-    viteConfig.plugins = flatPlugins;
+    viteConfig.plugins = await withoutIgnoredPlugins(viteConfig.plugins, ctx.config.viteIgnorePlugins);
     return viteConfig;
 }
 export async function getViteConfigWithPlugins(isServer, ctx) {
@@ -148,6 +149,10 @@ export async function getViteConfigWithPlugins(isServer, ctx) {
         config(_, { command }) {
             const collapsedVue = isServer || process.env['POVESTE_DEV'] ? {} : collapseVendoredVue({ root: ctx.root });
             return {
+                // The book is a single-page app whatever the project's framework says: a
+                // framework serving its own app sets `custom`, which turns off the fallback
+                // that serves `/story/...` (#1200).
+                appType: 'spa',
                 resolve: {
                     dedupe: [
                         'vue',
@@ -188,6 +193,7 @@ export async function getViteConfigWithPlugins(isServer, ctx) {
                         // bare `vue` was served raw beside the pre-bundled copy of the same
                         // file: two module instances, and `RouterView` rendered nothing (#1134).
                         ...(Object.keys(collapsedVue).length > 0 ? ['vue'] : []),
+                        ...isServer || process.env['POVESTE_DEV'] ? [] : chromePrebundles({ root: ctx.root }),
                     ],
                     exclude: [
                         'poveste',
@@ -328,6 +334,7 @@ export async function getViteConfigWithPlugins(isServer, ctx) {
             };
         },
     });
+    plugins.push(vendorsFromPoveste());
     plugins.push(createVirtualFilesPlugin(ctx, isServer));
     plugins.push(globalStylesPlugin({
         files: ctx.config.globalStyles ?? [],
@@ -355,7 +362,7 @@ export async function getViteConfigWithPlugins(isServer, ctx) {
             if (/\.(?:vue|js)(?:$|\?)/.test(id)) {
                 const original = code;
                 for (const [flag, value] of Object.entries(flags)) {
-                    code = code.replace(new RegExp(RegExp.escape(flag), 'g'), value);
+                    code = code.replace(new RegExp(escapeRegExp(flag), 'g'), value);
                 }
                 if (original !== code)
                     return code;
@@ -415,11 +422,11 @@ export async function getViteConfigWithPlugins(isServer, ctx) {
                                 ['vue', 'vue'],
                             ].reduce((acc, [name, entry]) => {
                                 acc.push({
-                                    find: new RegExp(`^${RegExp.escape(name)}$`),
+                                    find: new RegExp(`^${escapeRegExp(name)}$`),
                                     replacement: `@poveste/vendors/${entry}`,
                                 });
                                 acc.push({
-                                    find: new RegExp(`^${RegExp.escape(name)}/`),
+                                    find: new RegExp(`^${escapeRegExp(name)}/`),
                                     replacement: `@poveste/vendors/${entry}/`,
                                 });
                                 return acc;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "poveste",
   "type": "module",
-  "version": "0.17.2",
-  "description": "Interactive component playgrounds for Vue, Nuxt, Svelte, SvelteKit and Quasar — a drop-in fork of histoire, with Quasar support histoire does not ship.",
+  "version": "0.18.1",
+  "description": "Interactive component playgrounds for Vue, Nuxt, Svelte, SvelteKit and Quasar, plus Solid (renderer only) — a drop-in fork of histoire, with Quasar support histoire does not ship.",
   "author": {
     "name": "Sorin Gitlan",
     "url": "https://x.com/50rayn"
@@ -29,6 +29,8 @@
     "svelte",
     "nuxt",
     "sveltekit",
+    "solid",
+    "solidjs",
     "cli"
   ],
   "publishConfig": {
@@ -68,17 +70,17 @@
     "plugin.js"
   ],
   "engines": {
-    "node": ">=24.15.0"
+    "node": ">=22.22.2"
   },
   "peerDependencies": {
     "vite": "^8.0.0"
   },
   "dependencies": {
     "@11ty/gray-matter": "^3.0.0",
-    "@poveste/app": "^0.17.2",
-    "@poveste/controls": "^0.17.2",
-    "@poveste/shared": "^0.17.2",
-    "@poveste/vendors": "^0.17.2",
+    "@poveste/app": "^0.18.1",
+    "@poveste/controls": "^0.18.1",
+    "@poveste/shared": "^0.18.1",
+    "@poveste/vendors": "^0.18.1",
     "change-case": "^5.4.4",
     "chokidar": "^5.0.0",
     "defu": "^6.1.4",