poveste 0.18.0 → 0.18.2

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/dom/env.d.ts

@@ -1,7 +1,9 @@
+import './iterator.js';
 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,5 +1,11 @@
+/* eslint-disable perfectionist/sort-imports -- order is load order here */
+// First, and kept first: it defines `Iterator` where the runtime lacks it, and
+// jsdom extends `Iterator` while it loads (#1238).
+import './iterator.js';
 import { JSDOM, VirtualConsole, } from 'jsdom';
+import { isError } from '../util/is-error.js';
 import { populateGlobal } from './util.js';
+/* eslint-enable perfectionist/sort-imports */
 // jsdom error types — not exported by jsdom.
 const JSDOM_ERROR_CSS_PARSING = 'css-parsing';
 const JSDOM_ERROR_UNHANDLED_EXCEPTION = 'unhandled-exception';
@@ -26,7 +32,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 +49,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 +130,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 +145,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/dom/iterator.d.ts

@@ -0,0 +1,2 @@
+/** Defines `globalThis.Iterator` and its helpers where the runtime has neither. */
+export declare function installIterator(): void;

package/dist/node/dom/iterator.js

@@ -0,0 +1,213 @@
+// StackBlitz's WebContainer reports Node 22.22.3 but has no global `Iterator`, and
+// jsdom 30.1 extends it when it loads, so every story failed to collect there
+// (#1238). Real Node has had it since 22.0 and never runs this.
+//
+// Vendored rather than core-js: core-js and core-js-pure both carry a postinstall,
+// and pnpm 11 and 12 fail an install outright on a dependency's unapproved build
+// script. The full ES2025 helper set rather than only the `find` jsdom calls
+// today, so the next helper jsdom reaches for is already here.
+const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+function callable(fn, name) {
+    if (typeof fn !== 'function') {
+        throw new TypeError(`Iterator.prototype.${name} expects a function`);
+    }
+    return fn;
+}
+function count(value, name) {
+    const n = Number(value);
+    if (Number.isNaN(n)) {
+        throw new RangeError(`Iterator.prototype.${name} expects a number`);
+    }
+    const whole = Math.trunc(n);
+    if (whole < 0) {
+        throw new RangeError(`Iterator.prototype.${name} expects a non-negative number`);
+    }
+    return whole;
+}
+// Closing after a callback threw keeps the callback's error, as the spec does.
+function closeQuietly(iterator) {
+    try {
+        iterator.return?.();
+    }
+    catch { }
+}
+function guarded(iterator, run) {
+    try {
+        return run();
+    }
+    catch (error) {
+        closeQuietly(iterator);
+        throw error;
+    }
+}
+/**
+ * A lazy helper. `step` turns each value into what to yield, and `stop` ends it
+ * before the next read. The underlying iterator is closed whenever this one ends
+ * before it does.
+ */
+function lazy(iterator, step, stop = () => false) {
+    const next = iterator.next;
+    return (function* () {
+        let exhausted = false;
+        try {
+            for (let index = 0; !stop(); index++) {
+                const result = next.call(iterator);
+                if (result.done) {
+                    exhausted = true;
+                    return;
+                }
+                yield* guarded(iterator, () => step(result.value, index));
+            }
+        }
+        finally {
+            if (!exhausted) {
+                closeQuietly(iterator);
+            }
+        }
+    })();
+}
+/** An eager helper: `visit` returns true to stop, which closes the iterator. */
+function each(iterator, visit) {
+    const next = iterator.next;
+    for (let index = 0;; index++) {
+        const result = next.call(iterator);
+        if (result.done) {
+            return;
+        }
+        if (guarded(iterator, () => visit(result.value, index))) {
+            closeQuietly(iterator);
+            return;
+        }
+    }
+}
+function flattenable(value, name) {
+    if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
+        throw new TypeError(`Iterator.${name} expects an iterator or an iterable`);
+    }
+    const method = Reflect.get(value, Symbol.iterator);
+    const inner = method === undefined ? value : method.call(value);
+    return { [Symbol.iterator]: () => inner };
+}
+const helpers = {
+    map(fn) {
+        const mapper = callable(fn, 'map');
+        return lazy(this, (value, index) => [mapper(value, index)]);
+    },
+    filter(fn) {
+        const predicate = callable(fn, 'filter');
+        return lazy(this, (value, index) => (predicate(value, index) ? [value] : []));
+    },
+    take(limit) {
+        let remaining = count(limit, 'take');
+        return lazy(this, (value) => {
+            remaining--;
+            return [value];
+        }, () => remaining === 0);
+    },
+    drop(limit) {
+        let remaining = count(limit, 'drop');
+        return lazy(this, (value) => {
+            if (remaining > 0) {
+                remaining--;
+                return [];
+            }
+            return [value];
+        });
+    },
+    flatMap(fn) {
+        const mapper = callable(fn, 'flatMap');
+        return lazy(this, (value, index) => flattenable(mapper(value, index), 'prototype.flatMap'));
+    },
+    reduce(fn, ...initial) {
+        const reducer = callable(fn, 'reduce');
+        let accumulator = initial[0];
+        let started = initial.length > 0;
+        each(this, (value, index) => {
+            if (started) {
+                accumulator = reducer(accumulator, value, index);
+            }
+            else {
+                accumulator = value;
+                started = true;
+            }
+            return false;
+        });
+        if (!started) {
+            throw new TypeError('Iterator.prototype.reduce of an empty iterator with no initial value');
+        }
+        return accumulator;
+    },
+    toArray() {
+        const out = [];
+        each(this, (value) => {
+            out.push(value);
+            return false;
+        });
+        return out;
+    },
+    forEach(fn) {
+        const visit = callable(fn, 'forEach');
+        each(this, (value, index) => {
+            visit(value, index);
+            return false;
+        });
+    },
+    some(fn) {
+        const predicate = callable(fn, 'some');
+        let found = false;
+        each(this, (value, index) => {
+            found = Boolean(predicate(value, index));
+            return found;
+        });
+        return found;
+    },
+    every(fn) {
+        const predicate = callable(fn, 'every');
+        let all = true;
+        each(this, (value, index) => {
+            all = Boolean(predicate(value, index));
+            return !all;
+        });
+        return all;
+    },
+    find(fn) {
+        const predicate = callable(fn, 'find');
+        let found;
+        each(this, (value, index) => {
+            if (predicate(value, index)) {
+                found = value;
+                return true;
+            }
+            return false;
+        });
+        return found;
+    },
+};
+/** Defines `globalThis.Iterator` and its helpers where the runtime has neither. */
+export function installIterator() {
+    if (typeof Reflect.get(globalThis, 'Iterator') !== 'undefined') {
+        return;
+    }
+    function Iterator() {
+        if (new.target === undefined || new.target === Iterator) {
+            throw new TypeError('Iterator is an abstract class and cannot be constructed directly');
+        }
+    }
+    Iterator.prototype = IteratorPrototype;
+    Object.defineProperty(IteratorPrototype, 'constructor', { value: Iterator, writable: true, configurable: true });
+    Object.defineProperty(Iterator, 'from', {
+        value(value) {
+            const iterator = (typeof value === 'string' ? value : flattenable(value, 'from'))[Symbol.iterator]();
+            return Object.prototype.isPrototypeOf.call(IteratorPrototype, iterator) ? iterator : lazy(iterator, item => [item]);
+        },
+        writable: true,
+        configurable: true,
+    });
+    for (const [name, fn] of Object.entries(helpers)) {
+        if (!(name in IteratorPrototype)) {
+            Object.defineProperty(IteratorPrototype, name, { value: fn, writable: true, configurable: true });
+        }
+    }
+    Object.defineProperty(globalThis, 'Iterator', { value: Iterator, writable: true, configurable: true });
+}
+installIterator();

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.js

@@ -8,9 +8,10 @@ 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);
 /**
@@ -192,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',
@@ -332,6 +334,7 @@ export async function getViteConfigWithPlugins(isServer, ctx) {
             };
         },
     });
+    plugins.push(vendorsFromPoveste());
     plugins.push(createVirtualFilesPlugin(ctx, isServer));
     plugins.push(globalStylesPlugin({
         files: ctx.config.globalStyles ?? [],
@@ -359,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;
@@ -419,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,7 +1,7 @@
 {
   "name": "poveste",
   "type": "module",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "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",
@@ -70,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.18.0",
-    "@poveste/controls": "^0.18.0",
-    "@poveste/shared": "^0.18.0",
-    "@poveste/vendors": "^0.18.0",
+    "@poveste/app": "^0.18.2",
+    "@poveste/controls": "^0.18.2",
+    "@poveste/shared": "^0.18.2",
+    "@poveste/vendors": "^0.18.2",
     "change-case": "^5.4.4",
     "chokidar": "^5.0.0",
     "defu": "^6.1.4",