vike 0.4.219 → 0.4.220-commit-a9f46b8

package/dist/esm/client/client-routing-runtime/setScrollPosition.js

@@ -2,8 +2,12 @@ export { setScrollPosition };
 export { autoSaveScrollPosition };
 export { scrollToHashOrTop };
 import { assert, onPageHide, sleep, throttle } from './utils.js';
-import { saveScrollPosition } from './history.js';
-function setScrollPosition(scrollTarget) {
+import { replaceHistoryStateOriginal, saveScrollPosition } from './history.js';
+function setScrollPosition(scrollTarget, url) {
+    if (!scrollTarget && url && hasTextFragment(url)) {
+        scrollToTextFragment(url);
+        return;
+    }
     if (scrollTarget && 'x' in scrollTarget) {
         setScroll(scrollTarget);
         return;
@@ -14,6 +18,21 @@ function setScrollPosition(scrollTarget) {
     const hash = getUrlHash();
     scrollToHashOrTop(hash);
 }
+// https://github.com/vikejs/vike/issues/2114
+// https://github.com/WICG/scroll-to-text-fragment/issues/261
+function scrollToTextFragment(url) {
+    const stateOriginal = window.history.state;
+    replaceHistoryStateOriginal(null, url);
+    // We need `history.state===null` before location.replace() so that our 'popstate' handling is correct
+    assert(window.history.state === null);
+    // - Chrome's location.replace() keeps the current state (`history.state===stateOriginal`)
+    // - Firefox's location.replace() replaces the current state with `null` (`history.state===null`)
+    window.location.replace(url);
+    replaceHistoryStateOriginal(stateOriginal, url);
+}
+function hasTextFragment(url) {
+    return url.includes('#') && url.includes(':~:text');
+}
 // Replicates the browser's native behavior
 function scrollToHashOrTop(hash) {
     if (!hash) {
@@ -45,9 +64,14 @@ function scrollToTop() {
  * - Let's remove it and see if users complain?
  */
 function setScroll(scrollPosition) {
-    const scroll = () => window.scrollTo(scrollPosition.x, scrollPosition.y);
-    const done = () => window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
-    // In principle, this `done()` call should force the repaint to be finished. But that doesn't seem to be the case with `Firefox 97.0.1`.
+    const scroll = () => {
+        // `window.scrollTo()` respects the CSS `scroll-behavior: smooth` property
+        window.scrollTo(scrollPosition.x, scrollPosition.y);
+    };
+    const done = () => {
+        return window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
+    };
+    // In principle, this `done()` call should force the repaint to be finished, but that doesn't seem to be the case with `Firefox 97.0.1`.
     if (done())
         return;
     scroll();

package/dist/esm/client/client-routing-runtime/utils.d.ts

@@ -21,3 +21,4 @@ export * from '../../utils/onPageVisibilityChange.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/catchInfiniteLoop.js';

package/dist/esm/client/client-routing-runtime/utils.js

@@ -25,3 +25,4 @@ export * from '../../utils/onPageVisibilityChange.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/catchInfiniteLoop.js';

package/dist/esm/client/shared/normalizeClientSideUrl.js

@@ -2,9 +2,8 @@ export { normalizeClientSideUrl };
 import { assert, parseUrl } from './utils.js';
 /** Resolves relative URLs */
 function normalizeClientSideUrl(url, options) {
-    // This function doesn't work for `url === '#some-hash'` because `searchOriginal` is `null` even if window.location.href has a search string.
-    // - Thus the resolved absolute URL would be missing the search string.
-    // - It makes sense that `parseUrl()` returns `searchOriginal === null` since there isn't any search string in `url`.
+    // This function doesn't work for `url === '#some-hash'` because `searchOriginal` will be missing: if window.location.href has a search string then it's going to be missing in the returned `urlCurrent` value because `parseUrl(url)` returns `searchOriginal: null` since there isn't any search string in `url`.
+    // - Maybe `const { searchOriginal } = parseUrl(window.location.href)` can be a fix. (Let's check how `normalizeClientSideUrl()` is being used.)
     assert(!url.startsWith('#'));
     const { searchOriginal, hashOriginal, pathname } = parseUrl(url, '/');
     let urlCurrent = `${pathname}${searchOriginal || ''}`;

package/dist/esm/node/api/build.d.ts

@@ -1,13 +1,8 @@
 export { build };
-import { type Rollup } from 'vite';
 import type { APIOptions } from './types.js';
-type RollupOutput = Rollup.RollupOutput | Rollup.RollupOutput[] | Rollup.RollupWatcher;
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
-declare function build(options?: APIOptions): Promise<{
-    rollupOutputClient: RollupOutput;
-    rollupOutputServer: RollupOutput;
-}>;
+declare function build(options?: APIOptions): Promise<{}>;

package/dist/esm/node/api/build.js

@@ -1,37 +1,32 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite } from 'vite';
-import { isPrerenderAutoRunEnabled } from '../prerender/isPrerenderAutoRunEnabled.js';
+import assert from 'assert';
+import { isVikeCli } from '../cli/context.js';
+import { isPrerendering } from '../prerender/context.js';
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfigGlobal } = await prepareViteApiCall(options.viteConfig, 'build');
-    // Build client-side
-    const outputClient = await buildVite(viteConfigEnhanced);
-    // Build server-side
-    const outputServer = await buildVite(setSSR(viteConfigEnhanced));
-    // Pre-render
-    if (isPrerenderAutoRunEnabled(vikeConfigGlobal)) {
-        const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
-        await runPrerenderFromAutoRun(viteConfigEnhanced);
-    }
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'build');
+    // Pass it to autoFullBuild()
+    if (viteConfigEnhanced)
+        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    // 1. Build client-side
+    // 2. Build server-side
+    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
+    // 3. Pre-render (if enabled)
+    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
+    //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
+    //    > Rationale: https://github.com/vikejs/vike/issues/2123
+    await buildVite(viteConfigEnhanced);
+    // When using the Vike CLI with pre-rendering the process is forcefully exited at the end of the buildVite() call above
+    assert(!(isVikeCli() && isPrerendering()));
     return {
-        /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
-        viteConfig: viteConfigEnhanced,
-        */
-        rollupOutputClient: outputClient,
-        rollupOutputServer: outputServer
-    };
-}
-function setSSR(viteConfig) {
-    return {
-        ...viteConfig,
-        build: {
-            ...viteConfig?.build,
-            ssr: true
-        }
+    /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigEnhanced,
+    */
     };
 }

package/dist/esm/node/api/context.d.ts

@@ -1,7 +1,7 @@
-export { setOperation };
-export { clearOperation };
 export { isVikeCliOrApi };
+export { setContextApiOperation };
+export { clearContextApiOperation };
 import type { Operation } from './types.js';
 declare function isVikeCliOrApi(): boolean;
-declare function setOperation(operation: Operation): void;
-declare function clearOperation(): void;
+declare function setContextApiOperation(operation: Operation): void;
+declare function clearContextApiOperation(): void;

package/dist/esm/node/api/context.js

@@ -1,12 +1,9 @@
-// export { getOperation }
-export { setOperation };
-export { clearOperation };
 export { isVikeCliOrApi };
+export { setContextApiOperation };
+export { clearContextApiOperation };
 import { assert, getGlobalObject } from './utils.js';
-const globalObject = getGlobalObject('context.ts', {
-    apiOperation: undefined
-});
-function getOperation() {
+const globalObject = getGlobalObject('api/context.ts', {});
+function getApiOperation() {
     assert(globalObject.apiOperation);
     return globalObject.apiOperation;
 }
@@ -14,10 +11,10 @@ function isVikeCliOrApi() {
     // The CLI uses the API
     return !!globalObject.apiOperation;
 }
-function setOperation(operation) {
+function setContextApiOperation(operation) {
     assert(!globalObject.apiOperation);
     globalObject.apiOperation = operation;
 }
-function clearOperation() {
+function clearContextApiOperation() {
     globalObject.apiOperation = undefined;
 }

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -6,7 +6,6 @@ import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { Operation } from './types.js';
 declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
     viteConfigEnhanced: InlineConfig | undefined;
-    vikeConfigGlobal: import("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js").VikeConfigGlobal;
 }>;
 declare function getViteRoot(operation: 'build' | 'dev' | 'preview' | 'prerender'): Promise<string>;
 declare function normalizeViteRoot(root: string): string;

package/dist/esm/node/api/prepareViteApiCall.js

@@ -4,7 +4,7 @@ export { assertViteRoot };
 export { normalizeViteRoot };
 // TODO: enable Vike extensions to add Vite plugins
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
-import { clearOperation, setOperation } from './context.js';
+import { clearContextApiOperation, setContextApiOperation } from './context.js';
 import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import path from 'path';
 import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './utils.js';
@@ -13,31 +13,30 @@ import { clearGlobalContext } from '../runtime/globalContext.js';
 const globalObject = getGlobalObject('prepareViteApiCall.ts', {});
 async function prepareViteApiCall(viteConfig, operation) {
     clear();
-    setOperation(operation);
+    setContextApiOperation(operation);
     return enhanceViteConfig(viteConfig, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
-    clearOperation();
+    clearContextApiOperation();
     clearGlobalContext();
 }
 async function enhanceViteConfig(viteConfig, operation) {
     const viteInfo = await getInfoFromVite(viteConfig, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
-    const viteConfigEnhanced = addViteSettingsSetByUser(viteInfo.viteConfigEnhanced, vikeConfig);
+    const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
     return {
-        viteConfigEnhanced,
-        vikeConfigGlobal: vikeConfig.vikeConfigGlobal
+        viteConfigEnhanced
     };
 }
-function addViteSettingsSetByUser(viteConfigEnhanced, vikeConfig) {
+function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
     const viteConfigs = vikeConfig.global.from.configsCumulative.vite;
     if (!viteConfigs)
         return viteConfigEnhanced;
     viteConfigs.values.forEach((v) => {
         assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
-        viteConfigEnhanced = mergeConfig(v.value, viteConfigEnhanced ?? {});
+        viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, v.value);
     });
     return viteConfigEnhanced;
 }

package/dist/esm/node/cli/context.d.ts

@@ -0,0 +1,5 @@
+export { isVikeCli };
+export { setContextCliCommand };
+import type { Command } from './parseCli.js';
+declare function isVikeCli(): boolean;
+declare function setContextCliCommand(command: Command): void;

package/dist/esm/node/cli/context.js

@@ -0,0 +1,14 @@
+export { isVikeCli };
+export { setContextCliCommand };
+import { assert, getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('cli/context.ts', {});
+function getCliCommand() {
+    return globalObject.cliCommand;
+}
+function isVikeCli() {
+    return !!globalObject.cliCommand;
+}
+function setContextCliCommand(command) {
+    assert(!globalObject.cliCommand);
+    globalObject.cliCommand = command;
+}

package/dist/esm/node/cli/entry.js

@@ -2,9 +2,11 @@ import { projectInfo } from './utils.js';
 import { dev, build, preview } from '../api/index.js';
 import pc from '@brillout/picocolors';
 import { parseCli } from './parseCli.js';
+import { setContextCliCommand } from './context.js';
 cli();
 async function cli() {
     const { command } = parseCli();
+    setContextCliCommand(command);
     if (command === 'dev') {
         await cmdDev();
     }

package/dist/esm/node/cli/parseCli.d.ts

@@ -1,4 +1,6 @@
 export { parseCli };
+export type { Command };
+type Command = 'dev' | 'build' | 'preview' | 'prerender';
 declare function parseCli(): {
-    command: "build" | "dev" | "preview" | "prerender";
+    command: Command;
 };

package/dist/esm/node/cli/utils.d.ts

@@ -1,3 +1,4 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/includes.js';
+export * from '../../utils/getGlobalObject.js';

package/dist/esm/node/cli/utils.js

@@ -5,3 +5,4 @@ onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/includes.js';
+export * from '../../utils/getGlobalObject.js';

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -3,12 +3,14 @@ export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../prerender/runPrerender.js';
-import { isPrerenderAutoRunEnabled } from '../../prerender/isPrerenderAutoRunEnabled.js';
+import { isPrerenderAutoRunEnabled } from '../../prerender/context.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
 import { manifestTempFile } from './buildConfig.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { isVikeCliOrApi } from '../../api/context.js';
+import { isVikeCli } from '../../cli/context.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
@@ -69,22 +71,22 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
     if (!bundle[manifestTempFile])
         return;
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    const configInline = {
-        ...configFromCli,
-        configFile: configFromCli?.configFile || config.configFile,
-        root: config.root,
-        build: {
-            ...configFromCli?.build
-        }
-    };
-    try {
-        await build({
-            ...configInline,
+    let configInline;
+    if (config._viteConfigEnhanced) {
+        configInline = config._viteConfigEnhanced;
+    }
+    else {
+        configInline = {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
             build: {
-                ...configInline.build,
-                ssr: true
+                ...configFromCli?.build
             }
-        });
+        };
+    }
+    try {
+        await build(setSSR(configInline));
     }
     catch (err) {
         console.error(err);
@@ -92,10 +94,20 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
         process.exit(1);
     }
     if (isPrerenderAutoRunEnabled(vikeConfigGlobal)) {
-        await runPrerenderFromAutoRun(configInline);
-        forceExit = true;
+        const { prerenderContextPublic } = await runPrerenderFromAutoRun(configInline);
+        config.vike.prerenderContext = prerenderContextPublic;
+        forceExit = isVikeCli() || isViteCliCall();
     }
 }
+function setSSR(configInline) {
+    return {
+        ...configInline,
+        build: {
+            ...configInline.build,
+            ssr: true
+        }
+    };
+}
 function abortViteBuildSsr(vikeConfigGlobal) {
     if (vikeConfigGlobal.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
         assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
@@ -105,7 +117,8 @@ function abortViteBuildSsr(vikeConfigGlobal) {
 function isDisabled(vikeConfigGlobal) {
     const { disableAutoFullBuild } = vikeConfigGlobal;
     if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
-        return !isViteCliCall();
+        const isViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        return isViteApi;
     }
     else {
         return disableAutoFullBuild;

package/dist/esm/node/plugin/plugins/baseUrls.js

@@ -11,7 +11,7 @@ function baseUrls() {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            basesResolved = resolveBase(baseViteOriginal, config.vike.vikeConfigGlobal.baseServer, config.vike.vikeConfigGlobal.baseAssets);
+            basesResolved = resolveBase(baseViteOriginal, config._vikeConfigGlobal.baseServer, config._vikeConfigGlobal.baseAssets);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;
             process.env.BASE_ASSETS = basesResolved.baseAssets;

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -1,12 +1,18 @@
 export { commonConfig };
-import { type Plugin } from 'vite';
+import { type InlineConfig, type Plugin } from 'vite';
 import { type VikeConfigObject } from './importUserCode/v1-design/getVikeConfig.js';
+import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
 declare module 'vite' {
     interface UserConfig {
         _isDev?: boolean;
         _vikeVitePluginOptions?: unknown;
         _root?: string;
-        vike?: VikeConfigObject;
+        _viteConfigEnhanced?: InlineConfig;
+        vike?: {
+            global: VikeConfigObject['global'];
+            prerenderContext?: PrerenderContextPublic;
+        };
+        _vikeConfigGlobal?: VikeConfigObject['vikeConfigGlobal'];
     }
 }
 declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -11,7 +11,7 @@ import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
 import { getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
 import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
-import { temp_disablePrerenderAutoRun } from '../../prerender/isPrerenderAutoRunEnabled.js';
+import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 const pluginName = 'vike:commonConfig';
 function commonConfig(vikeVitePluginOptions) {
     return [
@@ -30,9 +30,11 @@ function commonConfig(vikeVitePluginOptions) {
                         _isDev: isDev,
                         _root: root,
                         _vikeVitePluginOptions: vikeVitePluginOptions,
-                        vike: vikeConfig,
-                        // TODO/v1-release: remove
-                        configVikePromise: Promise.resolve(vikeConfig.vikeConfigGlobal)
+                        vike: { global: vikeConfig.global },
+                        // TODO/now: remove
+                        _vikeConfigGlobal: vikeConfig.vikeConfigGlobal,
+                        // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
+                        configVikePromise: Promise.resolve({ prerender: !!vikeConfig.vikeConfigGlobal.prerender })
                     };
                 }
             }
@@ -75,7 +77,7 @@ function commonConfig(vikeVitePluginOptions) {
                     // VITE_CONFIG
                     const configFromEnvVar = getEnvVarObject('VITE_CONFIG');
                     if (configFromEnvVar)
-                        configFromVike = mergeConfig(configFromEnvVar, configFromVike);
+                        configFromVike = mergeConfig(configFromVike, configFromEnvVar);
                     return configFromVike;
                 }
             }
@@ -142,7 +144,7 @@ function assertVikeCliOrApi(config) {
         onlyOnce: true
     });
 }
-// TODO/v1-release: remove
+// TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
 function temp_supportOldInterface(config) {
     if (!('vitePluginSsr' in config))
         return;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -26,12 +26,13 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
-        const virtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
         lines.push(`  {`);
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
+        const virtualFileId = JSON.stringify(getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide));
+        const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
+        lines.push(`    loadConfigValuesAll: ${load},`);
         lines.push(`    configValuesSerialized: {`);
         lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
         lines.push(`    },`);

package/dist/esm/node/prerender/{isPrerenderAutoRunEnabled.d.ts → context.d.ts}

@@ -1,5 +1,9 @@
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
+export { isPrerendering };
+export { setContextIsPrerendering };
 import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 declare function isPrerenderAutoRunEnabled(vikeConfigGlobal: VikeConfigGlobal): boolean;
 declare function temp_disablePrerenderAutoRun(): void;
+declare function isPrerendering(): boolean;
+declare function setContextIsPrerendering(): void;

package/dist/esm/node/prerender/{isPrerenderAutoRunEnabled.js → context.js}

@@ -1,7 +1,9 @@
 export { isPrerenderAutoRunEnabled };
 export { temp_disablePrerenderAutoRun };
+export { isPrerendering };
+export { setContextIsPrerendering };
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
-const globalObject = getGlobalObject('isPrerenderAutoRunEnabled.ts', {});
+const globalObject = getGlobalObject('prerender/context.ts', {});
 function isPrerenderAutoRunEnabled(vikeConfigGlobal) {
     return (vikeConfigGlobal.prerender &&
         !vikeConfigGlobal.prerender.disableAutoRun &&
@@ -12,3 +14,9 @@ function isPrerenderAutoRunEnabled(vikeConfigGlobal) {
 function temp_disablePrerenderAutoRun() {
     globalObject.isDisabled = true;
 }
+function isPrerendering() {
+    return !!globalObject.isPrerendering;
+}
+function setContextIsPrerendering() {
+    globalObject.isPrerendering = true;
+}

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -3,8 +3,47 @@ export { runPrerenderFromCLIPrerenderCommand };
 export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
+export type { PrerenderContextPublic };
+import { PageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
+import { PageContextUrlInternal } from '../../shared/getPageContextUrlComputed.js';
 import type { APIOptions } from '../api/types.js';
+type ProvidedByHook = null | {
+    hookFilePath: string;
+    hookName: 'onBeforePrerenderStart' | 'prerender';
+};
+type TransformerHook = {
+    hookFilePath: string;
+    hookName: 'onPrerenderStart' | 'onBeforePrerender';
+};
+type PageContextPrerendered = {
+    urlOriginal: string;
+    _providedByHook?: ProvidedByHook;
+};
+type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
+type PrerenderContext = {
+    pageContexts: PageContext[];
+    pageContextInit: Record<string, unknown> | null;
+    noExtraDir: boolean;
+    prerenderedPageContexts: PrerenderedPageContexts;
+    output: Output;
+};
+type Output = {
+    filePath: string;
+    fileType: FileType;
+    fileContent: string;
+    pageContext: PageContextPrerendered;
+}[];
+type FileType = 'HTML' | 'JSON';
+type PrerenderContextPublic = Pick<PrerenderContext, 'pageContexts'>;
+type PageContext = PageContextInitEnhanced & {
+    _urlRewrite: null;
+    _urlHandler: null;
+    _urlOriginalBeforeHook?: string;
+    _urlOriginalModifiedByHook?: TransformerHook;
+    _providedByHook: ProvidedByHook;
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+} & PageContextUrlInternal;
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -29,5 +68,7 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<void>;
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<{
+    prerenderContextPublic: PrerenderContextPublic;
+}>;
 declare function runPrerender_forceExit(): void;