vike 0.4.162 → 0.4.163-commit-2305d5b

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

@@ -308,35 +308,41 @@ async function renderPageClientSide(renderArgs) {
                 }
             }
         };
-        // We use globalObject.renderPromise in order to ensure that there is never two concurrent onRenderClient() calls
-        if (globalObject.renderPromise) {
+        // We use globalObject.onRenderClientPromise in order to ensure that there is never two concurrent onRenderClient() calls
+        if (globalObject.onRenderClientPromise) {
             // Make sure that the previous render has finished
-            await globalObject.renderPromise;
-            assert(globalObject.renderPromise === undefined);
+            await globalObject.onRenderClientPromise;
+            assert(globalObject.onRenderClientPromise === undefined);
             if (isRenderOutdated())
                 return;
         }
         changeUrl(urlOriginal, overwriteLastHistoryEntry);
         globalObject.previousPageContext = pageContext;
-        assert(globalObject.renderPromise === undefined);
-        globalObject.renderPromise = (async () => {
+        assert(globalObject.onRenderClientPromise === undefined);
+        globalObject.onRenderClientPromise = (async () => {
+            let onRenderClientError;
             try {
                 await executeOnRenderClientHook(pageContext, true);
             }
             catch (err) {
-                await onError(err);
-                return;
+                onRenderClientError = err;
             }
-            addLinkPrefetchHandlers(pageContext);
-            globalObject.renderPromise = undefined;
+            globalObject.onRenderClientPromise = undefined;
+            return onRenderClientError;
         })();
-        await globalObject.renderPromise;
-        assert(globalObject.renderPromise === undefined);
+        const onRenderClientError = await globalObject.onRenderClientPromise;
+        assert(globalObject.onRenderClientPromise === undefined);
+        if (onRenderClientError) {
+            await onError(onRenderClientError);
+            if (!isErrorPage)
+                return;
+        }
         /* We don't abort in order to ensure that onHydrationEnd() is called: we abort only after onHydrationEnd() is called.
         if (isRenderOutdated(true)) return
         */
+        addLinkPrefetchHandlers(pageContext);
         // onHydrationEnd()
-        if (isHydrationRender) {
+        if (isHydrationRender && !onRenderClientError) {
             assertHook(pageContext, 'onHydrationEnd');
             const hook = getHook(pageContext, 'onHydrationEnd');
             if (hook) {
@@ -353,7 +359,7 @@ async function renderPageClientSide(renderArgs) {
                     return;
             }
         }
-        // We abort *after* onHydrationEnd() is called
+        // We purposely abort *after* onHydrationEnd() is called (see comment above).
         if (isRenderOutdated(true))
             return;
         // onPageTransitionEnd()

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

@@ -1,5 +1,5 @@
 export { getPageContextProxyForUser };
-import { assert, assertUsage, getGlobalObject } from '../server-routing-runtime/utils.js';
+import { assert, assertUsage, assertWarning, getGlobalObject } from '../server-routing-runtime/utils.js';
 import { notSerializable } from '../../shared/notSerializable.js';
 const globalObject = getGlobalObject('getPageContextProxyForUser.ts', {});
 /**
@@ -30,6 +30,10 @@ function assertIsDefined(pageContext, prop) {
         return;
     if (isExpected(prop))
         return;
+    // - If no pageContext was fetchd from the server, then adding props to passToClient is useless.
+    // - Showing a warning, even though no pageContext was fetched from the server, is actually erroneous as the client runtime cannot deduce the passToClient list.
+    if (!pageContext._hasPageContextFromServer)
+        return;
     const propName = JSON.stringify(prop);
     /* This handling would be the clearest but, unfortunately, it's fundamentally problematic:
      *  - It would force the pageContext value consumer to be synchronized with the pageContext value provider. For example, if vike-react wants to conditionally do something dependening on wehther some optional pageContext value was provided by some optional vike-react-* integration package.
@@ -37,7 +41,7 @@ function assertIsDefined(pageContext, prop) {
     const errMsg = `pageContext[${propName}] is \`undefined\` on the client-side. If it's defined on the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), otherwise make sure your client-side hooks always define it (e.g. set it to \`null\` instead of \`undefined\`).`
     assertUsage(false, errMsg)
     */
-    if (pageContext._hasPageContextFromServer && !pageContext._hasPageContextFromClient) {
+    if (!pageContext._hasPageContextFromClient) {
         // We can safely assume that the property is missing in passToClient, because the server-side defines all passToClient properties even if they have an undefined value:
         // ```
         // <script id="vike_pageContext" type="application/json">{"_pageId":"/pages/admin","user":"!undefined","pageProps":"!undefined","title":"!undefined","abortReason":"!undefined","_urlRewrite":null}</script>
@@ -47,6 +51,19 @@ function assertIsDefined(pageContext, prop) {
     }
     else {
         // Do nothing, not even a warning, because we don't know whether the user expects that the pageContext value can be undefined. (E.g. a pageContext value that is defined by an optional hook.)
+        // TODO/next-major-release make it an assertUsage()
+        assertWarning(false, [
+            `pageContext[${propName}] isn't defined on the client-side:`,
+            `1. if it's defined by the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), or`,
+            `2. if it's expected that it may not be defined:`,
+            '   ```js',
+            '   // ❌ Replace code like this:',
+            `   const val = pageContext[${propName}] ?? someDefaultValue`,
+            '   // ✅ With that:',
+            `   const val = ${propName} in pageContext ? pageContext[${propName}] : someDefaultValue`,
+            '   ```',
+            `See stack track below to find where pageContext[${propName}] is being accessed.`
+        ].join('\n'), { showStackTrace: true, onlyOnce: false });
     }
 }
 const IGNORE_LIST = [

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

@@ -6,6 +6,7 @@ import { getConfigVike } from '../../shared/getConfigVike.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';
 let forceExit = false;
 function autoFullBuild() {
     let config;
@@ -58,10 +59,12 @@ async function triggerFullBuild(config, configVike, bundle) {
         return; // already triggered
     if (isDisabled(configVike))
         return;
-    /* Is this @vitejs/plugin-legacy workaround still needed? Should we re-implement it?
-    // vike.json missing => it isn't a `$ vite build` call (e.g. @vitejs/plugin-legacy calls Vite's build() API) => skip
-    if (!bundle['vike.json']) return
-    */
+    // Workaround for @vitejs/plugin-legacy
+    //  - The legacy plugin triggers its own Rollup build for the client-side.
+    //  - The legacy plugin doesn't generate a manifest => we can use that to detect the legacy plugin build.
+    //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
+    if (!bundle[manifestTempFile])
+        return;
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
     const configInline = {
         ...configFromCli,

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

@@ -63,24 +63,28 @@ function buildConfig() {
         buildStart() {
             assertNodeEnv();
         },
-        async writeBundle(options, bundle) {
-            if (isSsrBuild) {
-                // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
-                //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
-                //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
-                const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
-                const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
-                const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
-                if (!isServerAssetsFixEnabled) {
-                    await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
-                }
-                else {
-                    const clientManifestMod = await fixServerAssets(outDirs);
-                    await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+        writeBundle: {
+            order: 'post',
+            sequential: true,
+            async handler(options, bundle) {
+                if (isSsrBuild) {
+                    // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
+                    //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
+                    //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
+                    const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
+                    const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
+                    const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+                    if (!isServerAssetsFixEnabled) {
+                        await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
+                    }
+                    else {
+                        const clientManifestMod = await fixServerAssets(outDirs);
+                        await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+                    }
+                    await fs.rm(clientManifestFilePath);
+                    await fs.rm(serverManifestFilePath);
+                    await set_constant_ASSETS_MAP(options, bundle);
                 }
-                await fs.rm(clientManifestFilePath);
-                await fs.rm(serverManifestFilePath);
-                await set_constant_ASSETS_MAP(options, bundle);
             }
         }
     };

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

@@ -1,5 +1,5 @@
 export { commonConfig };
-import { assert, assertWarning, findFile } from '../utils.js';
+import { assert, assertUsage, assertWarning, findFile } from '../utils.js';
 import { assertRollupInput } from './buildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -9,16 +9,18 @@ import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
+const pluginName = 'vike:commonConfig-1';
 function commonConfig() {
     return [
         {
-            name: 'vike-commonConfig-1',
+            name: pluginName,
             configResolved(config) {
+                assertSingleInstance(config);
                 installRequireShim_setUserRootDir(config.root);
             }
         },
         {
-            name: 'vike-.commonConfig-2',
+            name: 'vike:commonConfig-2',
             enforce: 'post',
             configResolved: {
                 order: 'post',
@@ -75,3 +77,7 @@ function assertEsm(userViteRoot) {
     dir = pc.dim(dir);
     assertWarning(packageJson.type === 'module', `We recommend setting ${dir}package.json#type to "module", see https://vike.dev/CJS`, { onlyOnce: true });
 }
+function assertSingleInstance(config) {
+    const numberOfInstances = config.plugins.filter((o) => o.name === pluginName).length;
+    assertUsage(numberOfInstances === 1, `Vike's Vite plugin (${pc.cyan("import vike from 'vike/plugin'")}) is being added ${numberOfInstances} times to the list of Vite plugins. Make sure to add it only once instead.`);
+}

package/dist/esm/node/plugin/plugins/importBuild/index.js

@@ -40,12 +40,11 @@ function getEntryCode(config, configVike) {
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
         `  {`,
         // We first set the values to a variable because of a Rollup bug, and this workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
-        `    const clientManifest = ${ASSETS_MAP};`,
+        `    const assetsManifest = ${ASSETS_MAP};`,
         `    const pluginManifest = ${JSON.stringify(vikeManifest, null, 2)};`,
         '    setImportBuildGetters({',
         `      pageFiles: () => pageFiles,`,
-        // TODO: rename clientManifest -> assetManifest
-        `      clientManifest: () => clientManifest,`,
+        `      getAssetsManifest: () => assetsManifest,`,
         // TODO: rename pluginManifest -> vikeManifest
         `      pluginManifest: () => pluginManifest,`,
         '    });',

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.d.ts

@@ -3,7 +3,7 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
-export type { VikeConfig };
+export type { VikeConfigObject };
 export type { InterfaceValueFile };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime, FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
@@ -21,13 +21,13 @@ type InterfaceValueFile = InterfaceFileCommons & {
     configName: string;
 };
 type ConfigName = string;
-type VikeConfig = {
+type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
     globalVikeConfig: Record<string, unknown>;
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(userRootDir: string, outDirRoot: string): void;
-declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
+declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean): Promise<VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;

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

@@ -469,7 +469,8 @@ function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden,
     interfaceFilesOverriden.forEach((interfaceFileLoser) => {
         const loserFilePath = interfaceFileLoser.filePath.filePathToShowToUser;
         const winnerFilePath = interfaceFileWinner.filePath.filePathToShowToUser;
-        assertWarning(false, `Config ${configName} defined at ${loserFilePath} is always overwritten by ${configName} defined at ${winnerFilePath}, remove the superfluous ${configName} value defined at ${interfaceFileLoser}`, { onlyOnce: false });
+        const confName = pc.cyan(configName);
+        assertWarning(false, `The value of the config ${confName} defined at ${loserFilePath} is always overwritten by the value defined at ${winnerFilePath}, remove the superfluous value defined at ${loserFilePath}`, { onlyOnce: true });
     });
 }
 function isInterfaceFileUserLand(interfaceFile) {
@@ -510,6 +511,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             valueIsFilePath: true,
             configEnv,
             valueIsImportedAtRuntime: true,
+            valueIsDefinedByValueFile: false,
             definedAt
         };
         return configValueSource;
@@ -525,6 +527,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 locationId,
                 configEnv,
                 valueIsImportedAtRuntime: true,
+                valueIsDefinedByValueFile: false,
                 definedAt: import_
             };
             // Load fake import
@@ -549,6 +552,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             value: configValue,
             configEnv,
             valueIsImportedAtRuntime: false,
+            valueIsDefinedByValueFile: false,
             definedAt: definedAtConfigFile
         };
         return configValueSource;
@@ -561,6 +565,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
             locationId,
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
+            valueIsDefinedByValueFile: true,
             definedAt: {
                 ...interfaceFile.filePath,
                 fileExportPathToShowToUser: configName === interfaceFile.configName

package/dist/esm/node/runtime/globalContext/loadImportBuild.d.ts

@@ -2,13 +2,13 @@ export { loadImportBuild };
 export { setImportBuildGetters };
 type BuildGetters = null | {
     pageFiles: () => Promise<Record<string, unknown>>;
-    clientManifest: () => Promise<Record<string, unknown>>;
+    getAssetsManifest: () => Promise<Record<string, unknown>>;
     pluginManifest: () => Promise<Record<string, unknown>>;
 };
 declare function setImportBuildGetters(getters: BuildGetters): void;
 declare function loadImportBuild(outDir?: string): Promise<{
     pageFiles: Record<string, unknown>;
-    clientManifest: Record<string, unknown>;
+    assetsManifest: Record<string, unknown>;
     pluginManifest: Record<string, unknown>;
 }>;
 declare global {

package/dist/esm/node/runtime/globalContext/loadImportBuild.js

@@ -13,11 +13,11 @@ async function loadImportBuild(outDir) {
         await importServerEntry(outDir);
         assert(buildGetters.getters);
     }
-    const [pageFiles, clientManifest, pluginManifest] = await Promise.all([
+    const [pageFiles, assetsManifest, pluginManifest] = await Promise.all([
         buildGetters.getters.pageFiles(),
-        buildGetters.getters.clientManifest(),
+        buildGetters.getters.getAssetsManifest(),
         buildGetters.getters.pluginManifest()
     ]);
-    const buildEntries = { pageFiles, clientManifest, pluginManifest };
+    const buildEntries = { pageFiles, assetsManifest, pluginManifest };
     return buildEntries;
 }

package/dist/esm/node/runtime/globalContext.d.ts

@@ -1,3 +1,5 @@
+export { getGlobalContextSync };
+export { getGlobalContextAsync };
 export { initGlobalContext };
 export { getGlobalContext };
 export { getViteDevServer };
@@ -10,6 +12,9 @@ import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { PluginManifest } from '../shared/assertPluginManifest.js';
 import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
 import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
+type GlobalContextPublic = {
+    assetsManifest: null | ViteManifest;
+};
 type GlobalContext = {
     baseServer: string;
     baseAssets: null | string;
@@ -22,11 +27,11 @@ type GlobalContext = {
     isPrerendering: false;
     viteConfig: ResolvedConfig;
     viteDevServer: ViteDevServer;
-    clientManifest: null;
+    assetsManifest: null;
     pluginManifest: null;
 } | ({
     isProduction: true;
-    clientManifest: ViteManifest;
+    assetsManifest: ViteManifest;
     pluginManifest: PluginManifest;
     viteDevServer: null;
 } & ({
@@ -37,6 +42,10 @@ type GlobalContext = {
     viteConfig: ResolvedConfig;
 })));
 declare function getGlobalContext(): GlobalContext;
+/** @experimental https://vike.dev/getGlobalContext */
+declare function getGlobalContextSync(): GlobalContextPublic;
+/** @experimental https://vike.dev/getGlobalContext */
+declare function getGlobalContextAsync(): Promise<GlobalContextPublic>;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
 declare function getViteDevServer(): ViteDevServer | null;
 declare function setGlobalContext_prerender(viteConfig: ResolvedConfig): void;

package/dist/esm/node/runtime/globalContext.js

@@ -1,3 +1,7 @@
+// Public use
+export { getGlobalContextSync };
+export { getGlobalContextAsync };
+// Internal use
 export { initGlobalContext };
 export { getGlobalContext };
 export { getViteDevServer };
@@ -5,18 +9,56 @@ export { getViteConfig };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_prerender };
 export { getRuntimeManifest };
-import { assert, assertUsage, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign } from './utils.js';
+import { assert, assertUsage, assertWarning, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign, objectKeys } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import pc from '@brillout/picocolors';
-const globalObject = getGlobalObject('globalContext.ts', {});
+let resolveGlobalContext;
+const globalObject = getGlobalObject('globalContext.ts', {
+    globalContextPromise: new Promise((r) => (resolveGlobalContext = r))
+});
 function getGlobalContext() {
     assert(globalObject.globalContext);
     return globalObject.globalContext;
 }
+/** @experimental https://vike.dev/getGlobalContext */
+function getGlobalContextSync() {
+    assertUsage(globalObject.globalContext, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContextAsync() instead.");
+    return makePublic(globalObject.globalContext);
+}
+/** @experimental https://vike.dev/getGlobalContext */
+async function getGlobalContextAsync() {
+    await globalObject.globalContextPromise;
+    assert(globalObject.globalContext);
+    return makePublic(globalObject.globalContext);
+}
+function makePublic(globalContext) {
+    const globalContextPublic = {
+        assetsManifest: globalContext.assetsManifest
+    };
+    // Add internals (and prepended _ prefix to their keys)
+    {
+        const publicKeys = Object.keys(globalContextPublic);
+        objectKeys(globalContext)
+            .filter((key) => !publicKeys.includes(key))
+            .forEach((key) => {
+            const keyPublic = `_${key}`;
+            Object.defineProperty(globalContextPublic, keyPublic, {
+                enumerable: true,
+                get() {
+                    assertWarning(false, `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`, {
+                        onlyOnce: true
+                    });
+                    return globalContext[key];
+                }
+            });
+        });
+    }
+    return globalContextPublic;
+}
 function setGlobalContext_viteDevServer(viteDevServer) {
     if (globalObject.viteDevServer)
         return;
@@ -51,7 +93,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
-            clientManifest: null,
+            assetsManifest: null,
             pluginManifest: null,
             viteDevServer,
             viteConfig,
@@ -66,13 +108,13 @@ async function initGlobalContext(isPrerendering = false, outDir) {
     else {
         const buildEntries = await loadImportBuild(outDir);
         assertBuildEntries(buildEntries, isPrerendering ?? false);
-        const { pageFiles, clientManifest, pluginManifest } = buildEntries;
+        const { pageFiles, assetsManifest, pluginManifest } = buildEntries;
         setPageFiles(pageFiles);
-        assertViteManifest(clientManifest);
+        assertViteManifest(assetsManifest);
         assertPluginManifest(pluginManifest);
         const globalContext = {
             isProduction: true,
-            clientManifest,
+            assetsManifest,
             pluginManifest,
             viteDevServer: null,
             baseServer: pluginManifest.baseServer,
@@ -100,6 +142,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
             globalObject.globalContext = globalContext;
         }
     }
+    resolveGlobalContext(globalObject.globalContext);
 }
 function getRuntimeManifest(configVike) {
     const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;

package/dist/esm/node/runtime/index-common.d.ts

@@ -2,6 +2,7 @@ export { renderPage } from './renderPage.js';
 export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
 export { PROJECT_VERSION as version } from './utils.js';
+export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 export { createPageRenderer } from '../createPageRenderer.js';
 declare global {

package/dist/esm/node/runtime/index-common.js

@@ -2,6 +2,7 @@ export { renderPage } from './renderPage.js';
 export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
 export { PROJECT_VERSION as version } from './utils.js';
+export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
 // TODO/v1-release: remove
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 // TODO/v1-release: remove

package/dist/esm/node/runtime/renderPage/getPageAssets/getManifestEntry.d.ts

@@ -1,6 +1,6 @@
 export { getManifestEntry };
 import type { ViteManifest, ViteManifestEntry } from '../../../shared/ViteManifest.js';
-declare function getManifestEntry(id: string, clientManifest: ViteManifest): {
+declare function getManifestEntry(id: string, assetsManifest: ViteManifest): {
     manifestKey: string;
     manifestEntry: ViteManifestEntry;
 };

package/dist/esm/node/runtime/renderPage/getPageAssets/getManifestEntry.js

@@ -3,13 +3,13 @@ import { assert, slice, isNpmPackageImport } from '../../utils.js';
 import { assertClientEntryId } from './assertClientEntryId.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
-function getManifestEntry(id, clientManifest) {
+function getManifestEntry(id, assetsManifest) {
     assertClientEntryId(id);
-    const debugInfo = getDebugInfo(id, clientManifest);
+    const debugInfo = getDebugInfo(id, assetsManifest);
     // Vike client entry
     if (id.startsWith('@@vike/')) {
         const manifestKeyEnd = slice(id, '@@vike'.length, 0);
-        const { manifestKey, manifestEntry } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+        const { manifestKey, manifestEntry } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
         assert(manifestEntry && manifestKey, debugInfo);
         return { manifestEntry, manifestKey };
     }
@@ -17,7 +17,7 @@ function getManifestEntry(id, clientManifest) {
     if (isVirtualFileIdPageConfigValuesAll(id)) {
         {
             const manifestKey = id;
-            const manifestEntry = clientManifest[manifestKey];
+            const manifestEntry = assetsManifest[manifestKey];
             if (manifestEntry) {
                 return { manifestEntry, manifestKey };
             }
@@ -30,20 +30,20 @@ function getManifestEntry(id, clientManifest) {
         //  - This workaround was implemented to support Vitest runnung /tests/*
         //    - I don't know whether end users actually need this workaround? (I'm not sure what the bug actually is.)
         const manifestKeyEnd = id;
-        const { manifestKey, manifestEntry } = getEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+        const { manifestKey, manifestEntry } = getEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
         assert(manifestEntry, debugInfo);
         return { manifestEntry, manifestKey };
     }
     // User files
     if (id.startsWith('/')) {
         const manifestKey = id.slice(1);
-        let manifestEntry = clientManifest[manifestKey];
+        let manifestEntry = assetsManifest[manifestKey];
         assert(manifestEntry, debugInfo);
         return { manifestEntry, manifestKey };
     }
     // npm package import
     if (isNpmPackageImport(id)) {
-        const found = Object.entries(clientManifest).find(([, e]) => e.name === prependEntriesDir(id));
+        const found = Object.entries(assetsManifest).find(([, e]) => e.name === prependEntriesDir(id));
         assert(found);
         const [manifestKey, manifestEntry] = found;
         return { manifestEntry, manifestKey };
@@ -55,7 +55,7 @@ function getManifestEntry(id, clientManifest) {
         assert(!manifestKeyEnd.startsWith('/'), debugInfo);
         manifestKeyEnd = '/' + manifestKeyEnd;
         {
-            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
             if (manifestEntry) {
                 assert(manifestKey, debugInfo);
                 return { manifestEntry, manifestKey };
@@ -69,7 +69,7 @@ function getManifestEntry(id, clientManifest) {
             assert(manifestKeyEnd.startsWith('/'), debugInfo);
         }
         {
-            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id);
+            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
             if (manifestEntry) {
                 assert(manifestKey, debugInfo);
                 return { manifestEntry, manifestKey };
@@ -79,11 +79,11 @@ function getManifestEntry(id, clientManifest) {
     }
     assert(false, debugInfo);
 }
-function findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
-    const debugInfo = getDebugInfo(id, clientManifest, manifestKeyEnd);
+function findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id) {
+    const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd);
     assert(manifestKeyEnd.startsWith('/'), debugInfo);
     const manifestKeys = [];
-    for (const manifestKey in clientManifest) {
+    for (const manifestKey in assetsManifest) {
         if (manifestKey.endsWith(manifestKeyEnd)) {
             manifestKeys.push(manifestKey);
         }
@@ -94,13 +94,13 @@ function findEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
     if (!manifestKey) {
         return { manifestEntry: null, manifestKey: null };
     }
-    const manifestEntry = clientManifest[manifestKey];
+    const manifestEntry = assetsManifest[manifestKey];
     return { manifestEntry, manifestKey };
 }
-function getEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
-    const debugInfo = getDebugInfo(id, clientManifest, manifestKeyEnd);
+function getEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id) {
+    const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd);
     const manifestKeys = [];
-    for (const manifestKey in clientManifest) {
+    for (const manifestKey in assetsManifest) {
         if (manifestKey.endsWith(manifestKeyEnd)) {
             manifestKeys.push(manifestKey);
         }
@@ -110,11 +110,11 @@ function getEntryWithKeyEnd(manifestKeyEnd, clientManifest, id) {
     if (!manifestKey) {
         return { manifestEntry: null, manifestKey: null };
     }
-    const manifestEntry = clientManifest[manifestKey];
+    const manifestEntry = assetsManifest[manifestKey];
     return { manifestEntry, manifestKey };
 }
-function getDebugInfo(id, clientManifest, manifestKeyEnd) {
-    const manifestKeys = Object.keys(clientManifest);
+function getDebugInfo(id, assetsManifest, manifestKeyEnd) {
+    const manifestKeys = Object.keys(assetsManifest);
     if (manifestKeyEnd === undefined) {
         return { manifestKeys, id };
     }

package/dist/esm/node/runtime/renderPage/getPageAssets/retrieveAssetsProd.d.ts

@@ -1,4 +1,4 @@
 export { retrieveAssetsProd };
 import type { ViteManifest } from '../../../shared/ViteManifest.js';
 import type { ClientDependency } from '../../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-declare function retrieveAssetsProd(clientDependencies: ClientDependency[], clientManifest: ViteManifest, includeAssetsImportedByServer: boolean): string[];
+declare function retrieveAssetsProd(clientDependencies: ClientDependency[], assetsManifest: ViteManifest, includeAssetsImportedByServer: boolean): string[];