vike 0.4.236 → 0.4.237-commit-8749e81

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

@@ -18,17 +18,23 @@ export { clearGlobalContext };
 export { assertBuildInfo };
 export { updateUserFiles };
 export { vikeConfigErrorRecoverMsg };
+// TODO/now: use isProductionEnvironment() instead of globalObject.isProduction
+// TODO/now: rename:
+//  - isProduction => isProductionEnvironment
+//  - setIsProduction => setIsProductionEnvironment
+//  - setGlobalContext_isProduction => setGlobalContext_isProductionEnvironment
+//  - sProductionEnvironment => sDevEnv
 // The core logic revolves around:
-// - virtualFileExports is the main requirement
+// - virtualFileExportsGlobalEntry is the main requirement
 // - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
-//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExports
+//   - loadBuildEntry() sets globalObject.buildEntry and then sets virtualFileExportsGlobalEntry
 //   - With vike-server it's set at server start: @brillout/vite-plugin-server-entry injects `import './entry.mjs'` (the production entry generated by @brillout/vite-plugin-server-entry) as first line of code of dist/server/index.mjs while dist/server/entry.mjs calls setGlobalContext_buildEntry()
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
-//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExports
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, getGlobalObject, genPromise, createDebugger, checkType, PROJECT_VERSION, } from './utils.js';
+//   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExportsGlobalEntry
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, getGlobalObject, genPromise, createDebugger, checkType, PROJECT_VERSION, getViteRPC, isRunnableDevEnvironment, assertIsNotBrowser, } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
-import { virtualFileIdEntryServer } from '../shared/virtualFiles/virtualFileEntry.js';
+import { virtualFileIdGlobalEntryServer } from '../shared/virtualFileId.js';
 import pc from '@brillout/picocolors';
 import { loadPageRoutes, loadPageRoutesSync } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
@@ -44,6 +50,7 @@ const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGloba
 // https://chat.deepseek.com/a/chat/s/d7e9f90a-c7f3-4108-9cd5-4ad6caed3539
 const globalObjectTyped = globalObject;
 const vikeConfigErrorRecoverMsg = pc.bold(pc.green('Vike config loaded'));
+assertIsNotBrowser();
 async function getGlobalContextServerInternal() {
     // getGlobalContextServerInternal() should always be called after initGlobalContext()
     assert(globalObject.isInitialized);
@@ -130,10 +137,12 @@ async function setGlobalContext_viteDevServer(viteDevServer) {
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
     globalObject.viteDevServerPromiseResolve(viteDevServer);
-    const { success } = await updateUserFiles();
-    if (!success)
-        return;
-    assertGlobalContextIsDefined();
+    if (isRunnable(viteDevServer)) {
+        const { success } = await updateUserFiles();
+        if (!success)
+            return;
+        assertGlobalContextIsDefined();
+    }
 }
 function setGlobalContext_viteConfig(viteConfig, viteConfigRuntime) {
     if (globalObject.viteConfig)
@@ -150,12 +159,14 @@ function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
     setIsProduction(true);
 }
-function setGlobalContext_isProduction(isProduction, tolerateContraditction) {
+function setGlobalContext_isProduction(isProduction, tolerateContradiction = false) {
+    if (debug.isActivated)
+        debug('setGlobalContext_isProduction()', { isProduction, tolerateContradiction });
     if (globalObject.isProduction === undefined) {
         setIsProduction(isProduction);
     }
     else {
-        assert(globalObject.isProduction === isProduction || tolerateContraditction);
+        assert(globalObject.isProduction === isProduction || tolerateContradiction);
     }
 }
 function getViteDevServer() {
@@ -199,7 +210,13 @@ async function initGlobalContext() {
     const { isProduction } = globalObject;
     assert(typeof isProduction === 'boolean');
     if (!isProduction) {
-        await globalObject.viteDevServerPromise;
+        if (isProcessSharedWithVite()) {
+            await globalObject.viteDevServerPromise;
+        }
+        else {
+            assert(isNonRunnableDev());
+            await updateUserFiles();
+        }
         assert(globalObject.waitForUserFilesUpdate);
         await globalObject.waitForUserFilesUpdate;
     }
@@ -256,7 +273,7 @@ async function loadBuildEntry(outDir) {
     assertBuildEntry(buildEntry);
     globalObject.assetsManifest = buildEntry.assetsManifest;
     globalObject.buildInfo = buildEntry.buildInfo;
-    await setGlobalContext(buildEntry.virtualFileExports);
+    await createGlobalContext(buildEntry.virtualFileExportsGlobalEntry);
 }
 // This is the production entry, see:
 // https://github.com/vikejs/vike/blob/798e5465dc3e3e6723b38b601a50350c0a006fb8/packages/vike/node/vite/plugins/pluginBuild/pluginBuildEntry.ts#L47
@@ -273,15 +290,15 @@ async function setGlobalContext_buildEntry(buildEntry) {
 }
 function assertBuildEntry(buildEntry) {
     assert(isObject(buildEntry));
-    assert(hasProp(buildEntry, 'virtualFileExports', 'object'));
-    const { virtualFileExports } = buildEntry;
+    assert(hasProp(buildEntry, 'virtualFileExportsGlobalEntry', 'object'));
+    const { virtualFileExportsGlobalEntry } = buildEntry;
     assert(hasProp(buildEntry, 'assetsManifest', 'object'));
     const { assetsManifest } = buildEntry;
     assertViteManifest(assetsManifest);
     assert(hasProp(buildEntry, 'buildInfo', 'object'));
     const { buildInfo } = buildEntry;
     assertBuildInfo(buildInfo);
-    checkType({ virtualFileExports, assetsManifest, buildInfo });
+    checkType({ virtualFileExportsGlobalEntry, assetsManifest, buildInfo });
 }
 function assertBuildInfo(buildInfo) {
     assert(isObject(buildInfo));
@@ -301,6 +318,7 @@ function assertVersionAtBuildTime(versionAtBuildTime) {
     assertUsage(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
 async function updateUserFiles() {
+    debug('updateUserFiles()');
     assert(!globalObject.isProduction);
     const { promise, resolve } = genPromise();
     globalObject.waitForUserFilesUpdate = promise;
@@ -333,27 +351,57 @@ async function updateUserFiles() {
         // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
         viteDevServer !== globalObject.viteDevServer;
     const { viteDevServer } = globalObject;
-    assert(viteDevServer);
     let hasError = false;
-    let virtualFileExports;
+    let virtualFileExportsGlobalEntry;
     let err;
-    try {
-        virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileIdEntryServer);
+    if (viteDevServer) {
+        assert(isRunnable(viteDevServer));
+        /* We don't use runner.import() yet, because as of vite@7.0.6 (July 2025) runner.import() unexpectedly invalidates the module graph, which is a unexpected behavior that doesn't happen with ssrLoadModule()
+        // Vite 6
+        try {
+          virtualFileExportsGlobalEntry = await (viteDevServer.environments.ssr as RunnableDevEnvironment).runner.import(
+            'virtual:vike:global-entry:server',
+          )
+        } catch (err_) {
+          hasError = true
+          err = err_
+        }
+        */
+        // Vite 5
+        try {
+            virtualFileExportsGlobalEntry = await viteDevServer.ssrLoadModule(virtualFileIdGlobalEntryServer);
+        }
+        catch (err_) {
+            hasError = true;
+            err = err_;
+        }
     }
-    catch (err_) {
-        hasError = true;
-        err = err_;
+    else {
+        try {
+            /* We use __VIKE__DYNAMIC_IMPORT instead of directly using import() to workaround what seems to be a Vite HMR bug:
+               ```js
+               assert(false)
+               // This line breaks the HMR of regular (runnable) apps, even though (as per the assert() above) it's never run. It seems to be a Vite bug: handleHotUpdate() receives an empty `modules` list.
+               import('virtual:vike:global-entry:server')
+               ```
+            */
+            virtualFileExportsGlobalEntry = await __VIKE__DYNAMIC_IMPORT('virtual:vike:global-entry:server');
+        }
+        catch (err_) {
+            hasError = true;
+            err = err_;
+        }
     }
     if (isOutdated())
         return { success: false };
     if (hasError)
         return onError(err);
-    virtualFileExports = virtualFileExports.default || virtualFileExports;
+    virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry.default || virtualFileExportsGlobalEntry;
     if (getVikeConfigErrorBuild()) {
         return { success: false };
     }
     try {
-        await setGlobalContext(virtualFileExports);
+        await createGlobalContext(virtualFileExportsGlobalEntry);
     }
     catch (err_) {
         hasError = true;
@@ -365,26 +413,26 @@ async function updateUserFiles() {
         return onError(err);
     return onSuccess();
 }
-async function setGlobalContext(virtualFileExports) {
-    debug('setGlobalContext()');
+async function createGlobalContext(virtualFileExportsGlobalEntry) {
+    debug('createGlobalContext()');
     assert(!getVikeConfigErrorBuild());
-    const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, addGlobalContextAsync, addGlobalContextSync);
+    const globalContext = await createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, addGlobalContext, addGlobalContextTmp, addGlobalContextAsync);
     assertV1Design(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     globalContext._pageConfigs.length > 0, globalContext._pageFilesAll);
     assertGlobalContextIsDefined();
     onSetupRuntime();
-    debug('setGlobalContext() - done');
-    // Never actually used, only used for TypeScript `ReturnType<typeof setGlobalContext>`
+    debug('createGlobalContext() - done');
+    // Never actually used, only used for TypeScript `ReturnType<typeof createGlobalContext>`
     return globalContext;
 }
-async function addGlobalContextAsync(globalContext) {
-    debug('addGlobalContextAsync()');
+async function addGlobalContextTmp(globalContext) {
+    debug('addGlobalContextTmp()');
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook);
 }
-function addGlobalContextSync(globalContext) {
-    debug('addGlobalContextSync()');
+function addGlobalContext(globalContext) {
+    debug('addGlobalContext()');
     const { pageRoutes, onBeforeRouteHook } = loadPageRoutesSync(globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal, globalContext._allPageIds);
     return addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook);
 }
@@ -394,23 +442,18 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
         _pageRoutes: pageRoutes,
         _onBeforeRouteHook: onBeforeRouteHook,
     };
-    const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction } = globalObject;
+    const { viteDevServer, viteConfig, isPrerendering, isProduction } = globalObject;
     assert(typeof isProduction === 'boolean');
     if (!isProduction) {
-        assert(viteDevServer);
         assert(globalContext); // main common requirement
-        assert(viteConfig);
-        assert(viteConfigRuntime);
         assert(!isPrerendering);
         return {
             ...globalContextBase,
-            ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
             _isProduction: false,
             _isPrerendering: false,
             assetsManifest: null,
             _viteDevServer: viteDevServer,
             viteConfig,
-            viteConfigRuntime,
         };
     }
     else {
@@ -421,11 +464,9 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
         assert(assetsManifest);
         const globalContextBase2 = {
             ...globalContextBase,
-            ...resolveBaseRuntime(buildInfo.viteConfigRuntime, globalContext.config),
             _isProduction: true,
             assetsManifest,
             _viteDevServer: null,
-            viteConfigRuntime: buildInfo.viteConfigRuntime,
             _usesClientRouter: buildInfo.usesClientRouter,
         };
         if (isPrerendering) {
@@ -445,6 +486,27 @@ function addGlobalContextCommon(globalContext, pageRoutes, onBeforeRouteHook) {
         }
     }
 }
+async function addGlobalContextAsync(globalContext) {
+    debug('addGlobalContextAsync()');
+    let { viteConfigRuntime, buildInfo } = globalObject;
+    if (!viteConfigRuntime) {
+        if (buildInfo) {
+            viteConfigRuntime = buildInfo.viteConfigRuntime;
+        }
+        else {
+            assert(!isProcessSharedWithVite()); // process shared with Vite => globalObject.viteConfigRuntime should be set
+            assert(!globalObject.isProduction); // production => globalObject.buildInfo.viteConfigRuntime should be set
+            assert(isNonRunnableDev());
+            const rpc = getViteRPC();
+            viteConfigRuntime = await rpc.getViteConfigRuntimeRPC();
+        }
+    }
+    assert(viteConfigRuntime);
+    return {
+        viteConfigRuntime,
+        ...resolveBaseRuntime(viteConfigRuntime, globalContext.config),
+    };
+}
 function clearGlobalContext() {
     debug('clearGlobalContext()');
     objectReplace(globalObject, getInitialGlobalObject(), ['buildEntryPrevious']);
@@ -453,6 +515,7 @@ function getInitialGlobalObject() {
     debug('getInitialGlobalObject()');
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
     return {
+        isProduction: isNonRunnableDev() ? false : undefined,
         viteDevServerPromise,
         viteDevServerPromiseResolve,
     };
@@ -463,3 +526,26 @@ function resolveBaseRuntime(viteConfigRuntime, config) {
     const baseAssetsUnresolved = config.baseAssets ?? null;
     return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
 }
+function isProcessSharedWithVite() {
+    const yes = globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE ?? false;
+    if (yes)
+        assert(!isNonRunnableDev());
+    return yes;
+}
+function isRunnable(viteDevServer) {
+    const yes = 
+    // Vite 5
+    !viteDevServer.environments ||
+        // Vite 6 or above
+        isRunnableDevEnvironment(viteDevServer.environments.ssr);
+    if (yes)
+        assert(!isNonRunnableDev());
+    return yes;
+}
+function isNonRunnableDev() {
+    if (typeof __VIKE__IS_NON_RUNNABLE_DEV === 'undefined')
+        return null;
+    const yes = __VIKE__IS_NON_RUNNABLE_DEV;
+    assert(typeof yes === 'boolean');
+    return yes;
+}

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -182,7 +182,7 @@ function mergeScriptEntries(pageAssets, viteDevScript) {
     return scriptEntry;
 }
 function getPageContextJsonScriptTag(pageContext) {
-    const pageContextClientSerialized = sanitizeJson(getPageContextClientSerialized(pageContext));
+    const pageContextClientSerialized = sanitizeJson(getPageContextClientSerialized(pageContext, true));
     const htmlTag = `<script id="${htmlElementId_pageContext}" type="application/json">${pageContextClientSerialized}</script>`;
     // Used by contra.com https://github.com/gajus
     // @ts-expect-error
@@ -190,7 +190,7 @@ function getPageContextJsonScriptTag(pageContext) {
     return htmlTag;
 }
 function getGlobalContextJsonScriptTag(pageContext) {
-    const globalContextClientSerialized = sanitizeJson(getGlobalContextClientSerialized(pageContext));
+    const globalContextClientSerialized = sanitizeJson(getGlobalContextClientSerialized(pageContext, true));
     const htmlTag = `<script id="${htmlElementId_globalContext}" type="application/json">${globalContextClientSerialized}</script>`;
     return htmlTag;
 }

package/dist/esm/node/runtime/html/injectAssets/getViteDevScript.js

@@ -1,5 +1,5 @@
 export { getViteDevScript };
-import { assert, assertUsage, assertWarning } from '../../utils.js';
+import { assert, assertUsage, assertWarning, getViteRPC } from '../../utils.js';
 import pc from '@brillout/picocolors';
 const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
 async function getViteDevScript(pageContext) {
@@ -11,7 +11,9 @@ async function getViteDevScript(pageContext) {
     const fakeHtmlBegin = '<html> <head>'; // White space to test whether user is using a minifier
     const fakeHtmlEnd = '</head><body></body></html>';
     let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;
-    fakeHtml = await viteDevServer.transformIndexHtml('/', fakeHtml);
+    fakeHtml = viteDevServer
+        ? await viteDevServer.transformIndexHtml('/', fakeHtml)
+        : await getViteRPC().transformIndexHtmlRPC(fakeHtml);
     assertUsage(!fakeHtml.includes('vite-plugin-pwa'), `The HTML transformer of ${pc.cyan('vite-plugin-pwa')} cannot be applied, see workaround at https://github.com/vikejs/vike/issues/388#issuecomment-1199280084`);
     assertUsage(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), `Vite plugins that minify the HTML cannot be applied, see https://github.com/vikejs/vike/issues/224`);
     assertUsage(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), `You are using a Vite Plugin that transforms the HTML in a way that conflicts with Vike. ${reachOutCTA}`);

package/dist/esm/node/runtime/html/serializeContext.d.ts

@@ -3,9 +3,12 @@ export { getPageContextClientSerializedAbort };
 export { getGlobalContextClientSerialized };
 export type { PageContextSerialization };
 export type { PassToClient };
+export type { PassToClientPublic };
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageContextSerialization = {
+import type { PageContextCreated } from '../renderPage/createPageContextServerSide.js';
+import type { PageContextBegin } from '../renderPage.js';
+type PageContextSerialization = PageContextCreated & {
     pageId: string;
     routeParams: Record<string, string>;
     _passToClient: PassToClient;
@@ -13,12 +16,14 @@ type PageContextSerialization = {
     pageProps?: Record<string, unknown>;
     _pageContextInit: Record<string, unknown>;
     _globalContext: GlobalContextServerInternal;
-    isClientSideNavigation: boolean;
+    _isPageContextJsonRequest: null | PageContextBegin['_isPageContextJsonRequest'];
 };
-declare function getPageContextClientSerialized(pageContext: PageContextSerialization): string;
-declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization): string;
-type PassToClient = (string | {
+declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
+declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
+type PassToClient = string[];
+type PassToClientPublic = (string | {
     prop: string;
+    /** @deprecated The passToClient once setting is deprecated and no longer has any effect. Instead, see the upcoming .once.js suffix (see https://github.com/vikejs/vike/issues/2566 for more information). */
     once?: boolean;
 })[];
 declare function getPageContextClientSerializedAbort(pageContext: Record<string, unknown> & ({
@@ -27,4 +32,4 @@ declare function getPageContextClientSerializedAbort(pageContext: Record<string,
     _urlRewrite: string;
 } | {
     abortStatusCode: number;
-})): string;
+}), isHtmlJsonScript: false): string;

package/dist/esm/node/runtime/html/serializeContext.js

@@ -25,63 +25,42 @@ const passToClientBuiltInPageContext = [
     'data', // for data() hook
 ];
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
-function getPageContextClientSerialized(pageContext) {
+function getPageContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClientPageContext = getPassToClientPageContext(pageContext);
-    const getObj = (passToClientEntry) => {
-        if (passToClientEntry.once)
-            return undefined; // pass it to client-side globalContext
-        return { obj: pageContext, objName: 'pageContext' };
-    };
-    const res = applyPassToClient(passToClientPageContext, getObj);
+    const res = applyPassToClient(passToClientPageContext, pageContext);
     const pageContextClient = res.objClient;
     const pageContextClientProps = res.objClientProps;
     if (pageContextClientProps.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient] = true;
     }
-    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, getObj);
+    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript);
     return pageContextClientSerialized;
 }
-function getGlobalContextClientSerialized(pageContext) {
+function getGlobalContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClient = pageContext._passToClient;
     const globalContext = pageContext._globalContext;
-    const getObj = ({ prop, once }) => {
-        if (once && getPropVal(pageContext, prop)) {
-            assert(typeof pageContext.isClientSideNavigation === 'boolean');
-            if (!pageContext.isClientSideNavigation) {
-                return { obj: pageContext, objName: 'pageContext' }; // pass it to client-side globalContext
-            }
-            else {
-                return undefined; // already passed to client-side
-            }
-        }
-        return { obj: globalContext, objName: 'globalContext' };
-    };
-    const res = applyPassToClient(passToClient, getObj);
+    const res = applyPassToClient(passToClient, globalContext);
     const globalContextClient = res.objClient;
-    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, getObj);
+    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, 'globalContext', isHtmlJsonScript);
     return globalContextClientSerialized;
 }
-function serializeObject(obj, passToClient, getObj) {
+function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
     let serialized;
     try {
-        serialized = serializeValue(obj);
+        serialized = serializeValue(obj, isHtmlJsonScript);
     }
     catch (err) {
         const h = (s) => pc.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
-        passToClient.forEach((entry) => {
-            const entryNormalized = normalizePassToClientEntry(entry);
-            const { prop } = entryNormalized;
+        passToClient.forEach((prop) => {
             const res = getPropVal(obj, prop);
             if (!res)
                 return;
             const { value } = res;
-            const { objName } = getObj(entryNormalized) ?? {};
-            assert(objName);
             const varName = `${objName}${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
-                serializeValue(value, varName);
+                serializeValue(value, isHtmlJsonScript, varName);
             }
             catch (err) {
                 propsNonSerializable.push(prop);
@@ -119,7 +98,7 @@ function serializeObject(obj, passToClient, getObj) {
             obj[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
         });
         try {
-            serialized = serializeValue(obj);
+            serialized = serializeValue(obj, isHtmlJsonScript);
         }
         catch (err) {
             assert(false);
@@ -127,20 +106,20 @@ function serializeObject(obj, passToClient, getObj) {
     }
     return serialized;
 }
-function serializeValue(value, varName) {
+function serializeValue(value, isHtmlJsonScript, varName) {
     return stringify(value, {
         forbidReactElements: true,
         valueName: varName,
         // Prevent Google from crawling URLs in JSON:
-        //  - https://github.com/vikejs/vike/discussions/2541#discussioncomment-13660198
-        //  - https://github.com/vikejs/vike/discussions/2277
-        //  - https://github.com/vikejs/vike/pull/2542
-        replacer(_key, value) {
-            if (typeof value === 'string' && value.startsWith('/')) {
-                // No need to use a reviver: https://github.com/brillout/json-serializer/blob/70fc8ed3741306391b51655b05df24e6963d1fdb/test/main.spec.ts#L74-L80
-                return { replacement: (value = '!' + value) };
-            }
-        },
+        // - https://github.com/vikejs/vike/pull/2603
+        // - https://github.com/brillout/json-serializer/blob/38edbb9945de4938da1e65d6285ce1dd123a45ef/test/main.spec.ts#L44-L95
+        replacer: !isHtmlJsonScript
+            ? undefined
+            : (_key, value) => {
+                if (typeof value === 'string') {
+                    return { replacement: value.replaceAll('/', '\\/'), resolved: false };
+                }
+            },
     });
 }
 function getPassToClientPageContext(pageContext) {
@@ -153,7 +132,7 @@ function getPassToClientPageContext(pageContext) {
     passToClient = unique(passToClient);
     return passToClient;
 }
-function getPageContextClientSerializedAbort(pageContext) {
+function getPageContextClientSerializedAbort(pageContext, isHtmlJsonScript) {
     assert(pageContext._urlRedirect || pageContext._urlRewrite || pageContext.abortStatusCode);
     assert(pageContext._abortCall);
     assert(pageContext._abortCaller);
@@ -186,17 +165,12 @@ function getPageContextClientSerializedAbort(pageContext) {
             onlyOnce: false,
         });
     }
-    return serializeValue(pageContext);
+    return serializeValue(pageContext, isHtmlJsonScript);
 }
-function applyPassToClient(passToClient, getObj) {
+function applyPassToClient(passToClient, obj) {
     const objClient = {};
     const objClientProps = [];
-    passToClient.forEach((entry) => {
-        const entryNormalized = normalizePassToClientEntry(entry);
-        const { prop } = entryNormalized;
-        const { obj } = getObj(entryNormalized) ?? {};
-        if (!obj)
-            return;
+    passToClient.forEach((prop) => {
         // Get value from pageContext
         const res = getPropVal(obj, prop);
         if (!res)
@@ -208,16 +182,3 @@ function applyPassToClient(passToClient, getObj) {
     });
     return { objClient, objClientProps };
 }
-function normalizePassToClientEntry(entry) {
-    let once;
-    let prop;
-    if (typeof entry === 'string') {
-        prop = entry;
-        once = false;
-    }
-    else {
-        prop = entry.prop;
-        once = entry.once ?? false;
-    }
-    return { prop, once };
-}

package/dist/esm/node/runtime/html/stream.js

@@ -522,8 +522,8 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const closeStream = async () => {
             if (isClosed)
                 return;
-            isClosed = true;
             await onEnd(isCancel);
+            isClosed = true;
             controllerProxy.close();
         };
         let controllerProxy;

package/dist/esm/node/runtime/renderPage/analyzePage.js

@@ -1,7 +1,7 @@
 export { analyzePage };
 import { getVikeClientEntry } from '../../../shared/getPageFiles/analyzePageClientSide/determineClientEntry.js';
 import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { getVirtualFileIdPageConfigLazy } from '../../shared/virtualFiles/virtualFilePageConfigLazy.js';
+import { generateVirtualFileId } from '../../shared/virtualFileId.js';
 import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
 import { getConfigValueRuntime } from '../../../shared/page-configs/getConfigValueRuntime.js';
 async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
@@ -15,14 +15,14 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             clientEntries.push(getVikeClientEntry(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
-            id: getVirtualFileIdPageConfigLazy(pageConfig.pageId, true),
+            id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: true }),
             onlyAssets: isClientRuntimeLoaded ? false : true,
             eagerlyImported: false,
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
         if (!globalContext._isProduction) {
             clientDependencies.push({
-                id: getVirtualFileIdPageConfigLazy(pageConfig.pageId, false),
+                id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: false }),
                 onlyAssets: true,
                 eagerlyImported: false,
             });