vike 0.4.242 → 0.4.243-commit-6ce9ef3

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

@@ -1,8 +1,5 @@
 export { getGlobalContextClientInternal };
-export type { GlobalContextClient };
 export type { GlobalContextClientInternal };
-import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
-type GlobalContextClient = GlobalContextBasePublic & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
 type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
 declare function getGlobalContextClientInternal(): Promise<{
     _globalConfigPublic: {

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

@@ -117,6 +117,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
         url: string;
         pageExports: Record<string, unknown>;
         isBaseMissing?: true;
+        ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
     }> & Pick<PageContextConfig & {
         isPageContext: true;
         Page: import("../../types/Config.js").Config["Page"];
@@ -138,6 +139,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
         url: string;
         pageExports: Record<string, unknown>;
         isBaseMissing?: true;
+        ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
     }, "exports" | "pageId" | "pageExports" | "config" | "Page" | "data" | "source" | "sources" | "from" | "configEntries" | "exportsAll" | "routeParams" | "abortReason"> & {
         isClientSide: true;
         isPrerendering: false;
@@ -145,7 +147,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+        globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {
@@ -182,6 +184,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     url: string;
     pageExports: Record<string, unknown>;
     isBaseMissing?: true;
+    ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
 }> & Pick<PageContextConfig & {
     isPageContext: true;
     Page: import("../../types/Config.js").Config["Page"];
@@ -203,6 +206,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     url: string;
     pageExports: Record<string, unknown>;
     isBaseMissing?: true;
+    ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
 }, "exports" | "pageId" | "pageExports" | "config" | "Page" | "data" | "source" | "sources" | "from" | "configEntries" | "exportsAll" | "routeParams" | "abortReason"> & {
     isClientSide: true;
     isPrerendering: false;
@@ -210,7 +214,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     isHydration: boolean;
     isBackwardNavigation: boolean | null;
     previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-    globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+    globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
 } & {
     urlOriginal: string;
 } & {
@@ -338,6 +342,7 @@ declare function getPageContextFromClientHooks(pageContext: {
         url: string;
         pageExports: Record<string, unknown>;
         isBaseMissing?: true;
+        ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
     }> & Pick<PageContextConfig & {
         isPageContext: true;
         Page: import("../../types/Config.js").Config["Page"];
@@ -359,6 +364,7 @@ declare function getPageContextFromClientHooks(pageContext: {
         url: string;
         pageExports: Record<string, unknown>;
         isBaseMissing?: true;
+        ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
     }, "exports" | "pageId" | "pageExports" | "config" | "Page" | "data" | "source" | "sources" | "from" | "configEntries" | "exportsAll" | "routeParams" | "abortReason"> & {
         isClientSide: true;
         isPrerendering: false;
@@ -366,7 +372,7 @@ declare function getPageContextFromClientHooks(pageContext: {
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+        globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {
@@ -401,6 +407,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     url: string;
     pageExports: Record<string, unknown>;
     isBaseMissing?: true;
+    ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
 }> & Pick<PageContextConfig & {
     isPageContext: true;
     Page: import("../../types/Config.js").Config["Page"];
@@ -422,6 +429,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     url: string;
     pageExports: Record<string, unknown>;
     isBaseMissing?: true;
+    ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
 }, "exports" | "pageId" | "pageExports" | "config" | "Page" | "data" | "source" | "sources" | "from" | "configEntries" | "exportsAll" | "routeParams" | "abortReason"> & {
     isClientSide: true;
     isPrerendering: false;
@@ -429,7 +437,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     isHydration: boolean;
     isBackwardNavigation: boolean | null;
     previousPageContext: import("../../types/PageContext.js").PageContextClient<unknown> | null;
-    globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+    globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
 } & {
     urlOriginal: string;
 } & {

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

@@ -1,5 +1,5 @@
 export { initOnLinkClick };
-import { isSameAsCurrentUrl, skipLink } from './skipLink.js';
+import { isLinkIgnored, isSameAsCurrentUrl, skipLink } from './skipLink.js';
 import { renderPageClientSide } from './renderPageClientSide.js';
 import { scrollToHashOrTop } from './setScrollPosition.js';
 function initOnLinkClick() {
@@ -14,6 +14,8 @@ async function onLinkClick(ev) {
     const href = linkTag.getAttribute('href');
     if (href === null)
         return;
+    if (isLinkIgnored(linkTag))
+        return;
     // Workaround for Firefox bug: clicking on a hash link that doesn't change the current URL causes Firefox to erroneously set `window.history.state = null` without firing any signal that we can detect.
     // - https://github.com/vikejs/vike/issues/1962
     // - https://github.com/sveltejs/kit/issues/8725

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

@@ -128,6 +128,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
         url: string;
         pageExports: Record<string, unknown>;
         isBaseMissing?: true;
+        ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
     }> & Pick<PageContextConfig & {
         isPageContext: true;
         Page: import("../../types/Config.js").Config["Page"];
@@ -149,6 +150,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
         url: string;
         pageExports: Record<string, unknown>;
         isBaseMissing?: true;
+        ignoreWarning?: import("../../shared/getProxyForPublicUsage.js").IgnoreWarning;
     }, "exports" | "pageId" | "pageExports" | "config" | "Page" | "data" | "source" | "sources" | "from" | "configEntries" | "exportsAll" | "routeParams" | "abortReason"> & {
         isClientSide: true;
         isPrerendering: false;
@@ -156,7 +158,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
         isHydration: boolean;
         isBackwardNavigation: boolean | null;
         previousPageContext: PageContextClient<unknown> | null;
-        globalContext: import("./getGlobalContextClientInternal.js").GlobalContextClient;
+        globalContext: import("../../types/GlobalContext.js").GlobalContextClient;
     } & {
         urlOriginal: string;
     } & {

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

@@ -1,4 +1,6 @@
 export { skipLink };
+export { isLinkIgnored };
 export { isSameAsCurrentUrl };
 declare function skipLink(linkTag: HTMLElement): boolean;
+declare function isLinkIgnored(linkTag: HTMLElement): boolean;
 declare function isSameAsCurrentUrl(href: string): boolean;

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

@@ -1,4 +1,6 @@
+// TODO: rename_full skipLink isLinkSkipped
 export { skipLink };
+export { isLinkIgnored };
 export { isSameAsCurrentUrl };
 import { normalizeClientSideUrl } from '../shared/normalizeClientSideUrl.js';
 import { getBaseServer } from './getBaseServer.js';
@@ -11,6 +13,7 @@ function skipLink(linkTag) {
         isUrlExternal(href) ||
         isSamePageHashLink(href) ||
         isNewTabLink(linkTag) ||
+        isLinkIgnored(linkTag) ||
         !hasBaseServer(href) ||
         // Purposely last because disableAutomaticLinkInterception will be removed in the next major release
         !isVikeLink(linkTag));
@@ -22,18 +25,25 @@ function isVikeLink(linkTag) {
         return true;
     }
     else {
+        // TODO: rename target attrVal
         const target = linkTag.getAttribute('data-vike-link');
         return target !== null && target !== 'false';
     }
 }
+// TODO rename
 function isNewTabLink(linkTag) {
     const target = linkTag.getAttribute('target');
     const rel = linkTag.getAttribute('rel');
     return target === '_blank' || target === '_external' || rel === 'external' || linkTag.hasAttribute('download');
 }
+function isLinkIgnored(linkTag) {
+    return linkTag.getAttribute('data-vike') === 'false';
+}
+// TODO refactor both functions below?
 function isSamePageHashLink(href) {
     if (href.startsWith('#'))
         return true;
+    // TODO: remove?
     if (href.includes('#') &&
         normalizeClientSideUrl(href, { withoutHash: true }) ===
             normalizeClientSideUrl(window.location.href, { withoutHash: true })) {

package/dist/esm/client/runtime-server-routing/getGlobalContextClientInternal.d.ts

@@ -1,8 +1,5 @@
 export { getGlobalContextClientInternal };
-export type { GlobalContextClientWithServerRouting };
 export type { GlobalContextClientInternalWithServerRouting };
-import type { GlobalContextBasePublic } from '../../shared/createGlobalContextShared.js';
-type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
 type GlobalContextClientInternalWithServerRouting = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
 declare function getGlobalContextClientInternal(): Promise<{
     _globalConfigPublic: {

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

@@ -3,9 +3,10 @@ import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { preview as previewVite } from 'vite';
 import { importServerProductionIndex } from '@brillout/vite-plugin-server-entry/runtime';
 import { getOutDirs } from '../vite/shared/getOutDirs.js';
-import { assertWarning, onSetupPreview } from './utils.js';
+import { assertUsage, assertWarning, onSetupPreview } from './utils.js';
 import pc from '@brillout/picocolors';
 import path from 'node:path';
+import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
 /**
  * Programmatically trigger `$ vike preview`
  *
@@ -14,7 +15,12 @@ import path from 'node:path';
 async function preview(options = {}) {
     onSetupPreview();
     const { viteConfigFromUserResolved, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
-    if (viteConfigResolved.vitePluginServerEntry?.inject) {
+    const vikeConfig = await getVikeConfigInternal();
+    const cliPreview = vikeConfig.config.cli?.preview;
+    assertUsage(cliPreview !== false, `${pc.cyan('$ vike preview')} isn't supported`);
+    const useVite = cliPreview === 'vite' || (cliPreview === undefined && !viteConfigResolved.vitePluginServerEntry?.inject);
+    if (!useVite) {
+        // Dynamically import() server production entry dist/server/index.js
         const outDir = getOutDirs(viteConfigResolved, undefined).outDirRoot;
         const { outServerIndex } = await importServerProductionIndex({ outDir });
         const outServerIndexRelative = path.relative(viteConfigResolved.root, outServerIndex);
@@ -24,6 +30,7 @@ async function preview(options = {}) {
         };
     }
     else {
+        // Use Vite's preview server
         const server = await previewVite(viteConfigFromUserResolved);
         return {
             viteServer: server,

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

@@ -20,17 +20,15 @@ export { updateUserFiles };
 export { isRunnable };
 export { vikeConfigErrorRecoverMsg };
 export type { BuildInfo };
-export type { GlobalContextServerInternal as GlobalContextServerInternal };
-export type { GlobalContextServer };
+export type { GlobalContextServerInternal };
 import type { ViteManifest } from '../../types/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { type PageRoutes } from '../../shared/route/loadPageRoutes.js';
 import type { ViteConfigRuntime } from '../vite/shared/getViteConfigRuntime.js';
-import type { GlobalContext } from '../../types/PageContext.js';
+import type { GlobalContext } from '../../types/GlobalContext.js';
 import type { Hook } from '../../shared/hooks/getHook.js';
 import type { PrerenderContext } from '../../types/index.js';
 declare const vikeConfigErrorRecoverMsg: "Vike config loaded";
-type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextServer;
 type GlobalContextServerInternal = Awaited<ReturnType<typeof createGlobalContext>>;
 declare function getGlobalContextServerInternal(): Promise<{
     globalContext: (Record<string, unknown> & {

package/dist/esm/node/vite/plugins/build/handleAssetsManifest.d.ts

@@ -3,14 +3,12 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
-export { handleAssetsManifest_workaroundCssTarget_part1 };
-export { handleAssetsManifest_workaroundCssTarget_part2 };
+export { handleAssetsManifest_alignCssTarget };
 import type { Environment, ResolvedConfig, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 declare function handleAssetsManifest_isFixEnabled(): boolean;
 declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
-declare function handleAssetsManifest_workaroundCssTarget_part1(config: ResolvedConfig): void;
-declare function handleAssetsManifest_workaroundCssTarget_part2(): void;
+declare function handleAssetsManifest_alignCssTarget(config: ResolvedConfig): void;
 declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig, env: Environment): void;
 declare function handleAssetsManifest_getBuildConfig(): Promise<{
     readonly ssrEmitAssets: true | undefined;

package/dist/esm/node/vite/plugins/build/handleAssetsManifest.js

@@ -3,8 +3,7 @@ export { handleAssetsManifest_getBuildConfig };
 export { handleAssetsManifest_isFixEnabled };
 export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
-export { handleAssetsManifest_workaroundCssTarget_part1 };
-export { handleAssetsManifest_workaroundCssTarget_part2 };
+export { handleAssetsManifest_alignCssTarget };
 import fs from 'node:fs/promises';
 import fs_sync from 'node:fs';
 import path from 'node:path';
@@ -20,7 +19,6 @@ import { set_macro_ASSETS_MANIFEST } from './pluginProdBuildEntry.js';
 import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
 const globalObject = getGlobalObject('handleAssetsManifest.ts', {
     assetsJsonFilePath: undefined,
-    cssTarget: '__VIKE__UNSET',
     targetsAll: [],
     configsAll: [],
 });
@@ -221,15 +219,13 @@ function handleAssetsManifest_assertUsageCssCodeSplit(config) {
         return;
     assertWarning(config.build.cssCodeSplit, `${pc.cyan('build.cssCodeSplit')} shouldn't be set to ${pc.cyan('false')} (https://github.com/vikejs/vike/issues/1993)`, { onlyOnce: true });
 }
-function handleAssetsManifest_workaroundCssTarget_part1(config) {
+function handleAssetsManifest_alignCssTarget(config) {
     globalObject.configsAll.push(config);
-    if (!isViteServerSide_viteEnvOptional(config, undefined)) {
-        globalObject.cssTarget = config.build.cssTarget;
-    }
-}
-function handleAssetsManifest_workaroundCssTarget_part2() {
-    assert(globalObject.cssTarget !== '__VIKE__UNSET');
-    globalObject.configsAll.forEach((c) => (c.build.cssTarget = globalObject.cssTarget));
+    const { cssTarget } = globalObject.configsAll
+        .filter((c) => !isViteServerSide_viteEnvOptional(c, undefined))
+        .at(-1).build;
+    assert(cssTarget);
+    globalObject.configsAll.forEach((c) => (c.build.cssTarget = cssTarget));
 }
 function handleAssetsManifest_assertUsageCssTarget(config, env) {
     if (!handleAssetsManifest_isFixEnabled())

package/dist/esm/node/vite/plugins/build/pluginBuildApp.js

@@ -113,9 +113,6 @@ function pluginBuildApp() {
                 handler() {
                     onSetupBuild();
                     handleAssetsManifest_assertUsageCssTarget(config, this.environment);
-                    /* Let vike:build:pluginBuildApp force exit
-                    runPrerender_forceExit()
-                    */
                 },
             },
         },

package/dist/esm/node/vite/plugins/build/pluginBuildConfig.js

@@ -10,31 +10,18 @@ import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { isViteServerSide_viteEnvOptional } from '../../shared/isViteServerSide.js';
-import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest_workaroundCssTarget_part1, handleAssetsManifest_workaroundCssTarget_part2, } from './handleAssetsManifest.js';
+import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest_alignCssTarget, } from './handleAssetsManifest.js';
 import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
 function pluginBuildConfig() {
-    let config;
     return [
-        {
-            name: 'vike:build:pluginBuildConfig:post1',
-            apply: 'build',
-            enforce: 'post',
-            configResolved: {
-                order: 'post',
-                handler(config_) {
-                    config = config_;
-                    handleAssetsManifest_workaroundCssTarget_part1(config);
-                },
-            },
-        },
         {
             name: 'vike:build:pluginBuildConfig:post2',
             apply: 'build',
             enforce: 'post',
             configResolved: {
                 order: 'post',
-                async handler() {
-                    handleAssetsManifest_workaroundCssTarget_part2();
+                async handler(config) {
+                    handleAssetsManifest_alignCssTarget(config);
                     onSetupBuild();
                     assertRollupInput(config);
                     const entries = await getEntries(config);

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -196,6 +196,10 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
     },
     middleware: { env: { server: true }, cumulative: true, eager: true, global: true },
+    cli: {
+        env: { config: true },
+        global: true,
+    },
     onPrerenderStart: {
         env: { server: true, production: true },
         eager: true,

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.js

@@ -740,10 +740,15 @@ function getConfigDefinitions(plusFilesRelevant, filter) {
         });
         objectEntries(meta).forEach(([configName, configDefinitionUserLand]) => {
             if ('isDefinedByPeerDependency' in configDefinitionUserLand) {
-                configDefinitionUserLand = {
-                    env: { client: false, server: false, config: false },
-                    ...configDefinitionUserLand,
-                };
+                /* vike-server@1.0.24 wrongfully sets `stream: { env: { config: true }, isDefinedByPeerDependency: true }`
+                assert(deepEqual(Object.keys(configDefinitionUserLand), ['isDefinedByPeerDependency']))
+                //*/
+                if (!configDefinitions[configName]) {
+                    configDefinitions[configName] = {
+                        env: { client: false, server: false, config: false },
+                    };
+                }
+                return;
             }
             // User can override an existing config definition
             configDefinitions[configName] = {

package/dist/esm/shared/getProxyForPublicUsage.d.ts

@@ -1,4 +1,7 @@
 export { getProxyForPublicUsage };
+export type { IgnoreWarning };
 type Target = Record<string, unknown>;
 type Fallback = (prop: string | symbol) => unknown;
 declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: 'pageContext' | 'globalContext' | 'prerenderContext' | 'vikeConfig', skipOnInternalProp?: true, fallback?: Fallback): Obj;
+/** https://vike.dev/warning/internals */
+type IgnoreWarning = (prop: string) => unknown;

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -10,25 +10,27 @@ import { NOT_SERIALIZABLE } from './NOT_SERIALIZABLE.js';
 import { assert, assertUsage, assertWarning, getPropAccessNotation, isBrowser } from './utils.js';
 function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
     return new Proxy(obj, {
-        get: getTrapGet(obj, objName, skipOnInternalProp, fallback),
+        get: (_, prop) => getProp(prop, obj, objName, skipOnInternalProp, fallback),
     });
 }
-function getTrapGet(obj, objName, skipOnInternalProp, fallback) {
-    return function (_, prop) {
-        const propStr = String(prop);
-        if (prop === '_isProxyObject')
-            return true;
-        if (!skipOnInternalProp)
+function getProp(prop, obj, objName, skipOnInternalProp, fallback) {
+    const propStr = String(prop);
+    if (prop === '_isProxyObject')
+        return true;
+    if (!skipOnInternalProp) {
+        if (prop === 'ignoreWarning')
+            return (prop) => getProp(prop, obj, objName, true, fallback);
+        if (!globalThis.__VIKE__IS_CLIENT)
             onInternalProp(propStr, objName);
-        if (fallback && !(prop in obj)) {
-            // Rudimentary flat pageContext implementation https://github.com/vikejs/vike/issues/1268
-            // Failed full-fledged implementation: https://github.com/vikejs/vike/pull/2458
-            return fallback(prop);
-        }
-        const val = obj[prop];
-        onNotSerializable(propStr, val, objName);
-        return val;
-    };
+    }
+    if (fallback && !(prop in obj)) {
+        // Rudimentary flat pageContext implementation https://github.com/vikejs/vike/issues/1268
+        // Failed full-fledged implementation: https://github.com/vikejs/vike/pull/2458
+        return fallback(prop);
+    }
+    const val = obj[prop];
+    onNotSerializable(propStr, val, objName);
+    return val;
 }
 function onNotSerializable(propStr, val, objName) {
     if (val !== NOT_SERIALIZABLE)
@@ -38,17 +40,15 @@ function onNotSerializable(propStr, val, objName) {
     assertUsage(false, `Can't access ${objName}${propName} on the client side. Because it can't be serialized, see server logs.`);
 }
 function onInternalProp(propStr, objName) {
-    // - We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
-    // - TO-DO/eventually: use import.meta.CLIENT instead of isBrowser()
-    //   - Where import.meta.CLIENT is defined by Vike
-    //   - Using import.meta.env.CLIENT (note `.env.`) doesn't seem possible: https://github.com/brillout/playground_node_import.meta.env
-    //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
-    if (isBrowser())
-        return;
+    // We must skip it on the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    assert(!isBrowser());
     // TO-DO/soon/proxy: remove this and only warn on built-in access instead
     if (propStr === '_configFromHook')
         return;
     if (propStr.startsWith('_')) {
-        assertWarning(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub to request official support for your use case.`, { onlyOnce: true, showStackTrace: true });
+        assertWarning(false, `Using internal ${objName}.${propStr} — https://vike.dev/warning/internals`, {
+            onlyOnce: true,
+            showStackTrace: true,
+        });
     }
 }

package/dist/esm/shared/modifyUrlSameOrigin.js

@@ -1,12 +1,12 @@
 export { modifyUrlSameOrigin };
 // We don't move modifyUrlSameOrigin() to the modifyUrl.ts file because we plan to use modifyUrlSameOrigin() on the client-side:
 // https://github.com/vikejs/vike/blob/c5a2de5e85262771f97851767c00ac35da69c64b/packages/vike/client/runtime-client-routing/navigate.ts#L4
-import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathnameAbsolute, } from './utils.js';
+import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathAbsolute, } from './utils.js';
 function modifyUrlSameOrigin(url, modify) {
     const urlParsed = parseUrl(url, '/');
     // Pathname
     const pathname = modify.pathname ?? urlParsed.pathnameOriginal;
-    assertUsageUrlPathnameAbsolute(pathname, 'modify.pathname');
+    assertUsageUrlPathAbsolute(pathname, 'modify.pathname');
     // Search
     let search = modify.search === null ? '' : !modify.search ? urlParsed.searchOriginal : resolveSearch(urlParsed, modify.search);
     if (search === '?')

package/dist/esm/shared/route/abort.js

@@ -8,7 +8,7 @@ export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
 import { isUserHookError } from '../hooks/execHook.js';
-import { assert, assertInfo, assertUsage, assertUsageUrlPathnameAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, isBrowser, joinEnglish, objectAssign, truncateString, } from './utils.js';
+import { assert, assertInfo, assertUsage, assertUsageUrlPathAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, isBrowser, joinEnglish, objectAssign, truncateString, } from './utils.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.
@@ -66,7 +66,7 @@ function render_(urlOrStatusCode, abortReason, abortCall, abortCaller, pageConte
     }
     if (typeof urlOrStatusCode === 'string') {
         const url = urlOrStatusCode;
-        assertUsageUrlPathnameAbsolute(url, getErrPrefix(abortCaller));
+        assertUsageUrlPathAbsolute(url, getErrPrefix(abortCaller));
         objectAssign(pageContextAbort, {
             _urlRewrite: url,
         });

package/dist/esm/shared/route/execHookOnBeforeRoute.js

@@ -1,6 +1,6 @@
 export { execHookOnBeforeRoute };
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
-import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlPathnameAbsolute, joinEnglish, assert, } from './utils.js';
+import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlAbsolute, joinEnglish, assert, } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
 import { execHookDirectSync } from '../hooks/execHook.js';
@@ -65,8 +65,8 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
         delete hookReturn.pageContext.urlOriginal;
     }
     if (hasProp(hookReturn.pageContext, 'urlLogical')) {
-        assertUsageUrlPathnameAbsolute(
-        // We skip validation and type-cast instead of assertUsage() in order to save client-side KBs
+        assertUsageUrlAbsolute(
+        // We type-cast instead of assertUsage() validation in order to save client-side KBs
         hookReturn.pageContext.urlLogical, `${errPrefix} returned ${pc.cyan('{ pageContext: { urlLogical } }')} and ${pc.cyan('urlLogical')}`);
     }
     assertPageContextProvidedByUser(hookReturn.pageContext, {

package/dist/esm/types/Config.d.ts

@@ -42,7 +42,8 @@ import type { InjectFilterEntry } from './index.js';
 import type { VikeVitePluginOptions } from '../node/vite/index.js';
 import type { Vike } from './VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../shared/hooks/getHook.js';
-import type { GlobalContext, PageContextClient, PageContextServer } from './PageContext.js';
+import type { PageContextClient, PageContextServer } from './PageContext.js';
+import type { GlobalContext } from './GlobalContext.js';
 import type { InlineConfig } from 'vite';
 import type { PassToClientPublic } from '../node/runtime/renderPage/html/serializeContext.js';
 type HookNameOld = HookName | HookNameOldDesign;
@@ -512,6 +513,10 @@ type ConfigBuiltIn = {
     keepScrollPosition?: KeepScrollPosition;
     /** @experimental */
     middleware?: Function;
+    /** @experimental */
+    cli?: {
+        preview?: boolean | 'vite';
+    };
 };
 type ConfigBuiltInResolved = {
     passToClient?: string[][];

package/dist/esm/types/GlobalContext.d.ts

@@ -0,0 +1,17 @@
+export type { GlobalContext };
+export type { GlobalContextServer };
+export type { GlobalContextClient };
+export type { GlobalContextClientWithServerRouting };
+import type { GlobalContextServerInternal } from '../node/runtime/globalContext.js';
+import type { GlobalContextClientInternalWithServerRouting } from '../client/runtime-server-routing/getGlobalContextClientInternal.js';
+import type { GlobalContextBasePublic } from '../shared/createGlobalContextShared.js';
+import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
+import type { IgnoreWarning } from '../shared/getProxyForPublicUsage.js';
+type GlobalContext = GlobalContextServer | GlobalContextClient;
+type GlobalContextServer = GlobalContextCommon & Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextServer;
+type GlobalContextClient = GlobalContextCommon & GlobalContextBasePublic & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClientWithServerRouting = GlobalContextCommon & GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextCommon = {
+    /** https://vike.dev/warning/internals */
+    ignoreWarning?: IgnoreWarning;
+};

package/dist/esm/types/GlobalContext.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/PageContext.d.ts

@@ -1,12 +1,8 @@
 export type { PageContext };
 export type { PageContextServer };
 export type { PageContextClient };
-export type { GlobalContext };
-export type { GlobalContextServer };
-export type { GlobalContextClient };
 export type { PageContextWithServerRouting };
 export type { PageContextClientWithServerRouting };
-export type { GlobalContextClientWithServerRouting };
 export type { PageContextInternalServer };
 export type { PageContextInternalClient };
 export type { PageContextInternalClient_ServerRouting };
@@ -18,13 +14,11 @@ import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer
 import type { From, PageContextConfig, Source, Sources } from '../shared/page-configs/resolveVikeConfigPublic.js';
 import type { Config } from './Config.js';
 import type { AbortStatusCode } from '../shared/route/abort.js';
-import type { GlobalContextServer } from '../node/runtime/globalContext.js';
-import type { GlobalContextClient } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
-import type { GlobalContextClientWithServerRouting } from '../client/runtime-server-routing/getGlobalContextClientInternal.js';
+import type { GlobalContextClient, GlobalContextServer, GlobalContextClientWithServerRouting } from './GlobalContext.js';
+import type { IgnoreWarning } from '../shared/getProxyForPublicUsage.js';
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & Vike.PageContext & Vike.PageContextServer;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
 type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & Vike.PageContext & Vike.PageContextClient;
-type GlobalContext = GlobalContextServer | GlobalContextClient;
 type PageContextWithServerRouting<Data = unknown> = PageContextClientWithServerRouting<Data> | PageContextServer<Data>;
 type PageContextClientWithServerRouting<Data = unknown> = PageContextBuiltInClientWithServerRouting<Data> & Vike.PageContext & Vike.PageContextClient;
 type PageContextBuiltInCommon<Data> = PageContextConfig & {
@@ -134,6 +128,8 @@ type PageContextBuiltInCommon<Data> = PageContextConfig & {
      * https://vike.dev/pageContext#isBaseMissing
      */
     isBaseMissing?: true;
+    /** https://vike.dev/warning/internals */
+    ignoreWarning?: IgnoreWarning;
 };
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
     /**

package/dist/esm/types/index.d.ts

@@ -1,4 +1,5 @@
-export type { PageContext, PageContextServer, PageContextClient, GlobalContext, GlobalContextServer, GlobalContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, GlobalContextClientWithServerRouting, } from './PageContext.js';
+export type { PageContext, PageContextServer, PageContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, } from './PageContext.js';
+export type { GlobalContext, GlobalContextServer, GlobalContextClient, GlobalContextClientWithServerRouting, } from './GlobalContext.js';
 export type { PrerenderContextPublic as PrerenderContext } from '../node/prerender/runPrerender.js';
 export type { PageContextBuiltInServer } from './PageContext.js';
 export type { PageContextBuiltInClientWithClientRouting } from './PageContext.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.242";
+export declare const PROJECT_VERSION: "0.4.243-commit-6ce9ef3";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.242';
+export const PROJECT_VERSION = '0.4.243-commit-6ce9ef3';

package/dist/esm/utils/parseUrl.d.ts

@@ -1,5 +1,6 @@
 export { parseUrl };
-export { assertUsageUrlPathnameAbsolute };
+export { assertUsageUrlAbsolute };
+export { assertUsageUrlPathAbsolute };
 export { assertUsageUrlRedirectTarget };
 export { isUrl };
 export { isUri };
@@ -52,5 +53,6 @@ declare function isUrlRedirectTarget(url: string): boolean;
 declare function isUrlRelative(url: string): boolean;
 declare function isUrlExternal(url: string): boolean;
 declare function isUri(uri: string): boolean;
-declare function assertUsageUrlPathnameAbsolute(url: string, errPrefix: string): void;
+declare function assertUsageUrlAbsolute(url: string, errPrefix: string): void;
+declare function assertUsageUrlPathAbsolute(url: string, errPrefix: string): void;
 declare function assertUsageUrlRedirectTarget(url: string, errPrefix: string, isUnresolved?: true): void;

package/dist/esm/utils/parseUrl.js

@@ -3,7 +3,8 @@
 //  - It doesn't support the tauri:// protocol
 // Unit tests at ./parseUrl.spec.ts
 export { parseUrl };
-export { assertUsageUrlPathnameAbsolute };
+export { assertUsageUrlAbsolute };
+export { assertUsageUrlPathAbsolute };
 export { assertUsageUrlRedirectTarget };
 export { isUrl };
 export { isUri };
@@ -53,6 +54,10 @@ function parseUrl(url, baseServer) {
     const { hostname, port } = parseHost(host, url);
     // decode after setting href
     pathname = decodePathname(pathname);
+    /* Should it be `pathname` or `pathnameOriginal`? https://github.com/vikejs/vike/pull/2770
+    // pageContext.urlParsed.path
+    const path = pathname + (searchOriginal || '') + (hashOriginal || '')
+    */
     assert(pathname.startsWith('/'));
     return {
         href,
@@ -135,7 +140,7 @@ function getBaseURI() {
     return baseURI;
 }
 function parseOrigin(url) {
-    if (!isUrlWithProtocol(url)) {
+    if (!isUrlWithWebProtocol(url)) {
         return { pathname: url, origin: null, protocol: null };
     }
     else {
@@ -181,7 +186,7 @@ function parseProtocol(uri) {
     }
     return { protocol, uriWithoutProtocol };
 }
-function isUrlProtocol(protocol) {
+function isWebUrlProtocol(protocol) {
     // Is there an alternative to having a blocklist?
     // - If the blocklist becomes too big, maybe use a allowlist instead ['tauri://', 'file://', 'capacitor://', 'http://', 'https://']
     const blocklist = [
@@ -264,10 +269,16 @@ function createUrlFromComponents(origin, pathname, search, hash) {
 }
 function isUrl(url) {
     // parseUrl() works with these URLs
-    return isUrlWithProtocol(url) || url.startsWith('/') || isUrlRelative(url);
+    return isUrlAbsolute(url) || isUrlRelative(url);
 }
 function isUrlRedirectTarget(url) {
-    return url.startsWith('/') || isUri(url) || isUrlWithProtocol(url);
+    return isUrlAbsolute(url) || isUri(url);
+}
+function isUrlAbsolute(url) {
+    return isUrlPathAbsolute(url) || isUrlWithWebProtocol(url);
+}
+function isUrlPathAbsolute(url) {
+    return url.startsWith('/');
 }
 function isUrlRelative(url) {
     return ['.', '?', '#'].some((c) => url.startsWith(c)) || url === '';
@@ -288,9 +299,9 @@ URL with protocol.
 [Electron (`file://`)](https://github.com/vikejs/vike/issues/1557)
 [Capacitor](https://github.com/vikejs/vike/issues/1706)
  */
-function isUrlWithProtocol(url) {
+function isUrlWithWebProtocol(url) {
     const { protocol } = parseProtocol(url);
-    return !!protocol && isUrlProtocol(protocol);
+    return !!protocol && isWebUrlProtocol(protocol);
 }
 /*
 URIs that aren't URLs.
@@ -308,27 +319,23 @@ We need to treat URIs differently than URLs.
 */
 function isUri(uri) {
     const { protocol } = parseProtocol(uri);
-    return !!protocol && !isUrlProtocol(uri);
+    return !!protocol && !isWebUrlProtocol(protocol);
+}
+function assertUsageUrlAbsolute(url, errPrefix) {
+    assertUsage(isUrlAbsolute(url), getErrMsg(url, errPrefix, true));
 }
-function assertUsageUrlPathnameAbsolute(url, errPrefix) {
-    assertUsageUrl(url, errPrefix);
+function assertUsageUrlPathAbsolute(url, errPrefix) {
+    assertUsage(isUrlPathAbsolute(url), getErrMsg(url, errPrefix));
 }
 function assertUsageUrlRedirectTarget(url, errPrefix, isUnresolved) {
-    assertUsageUrl(url, errPrefix, { isRedirectTarget: isUnresolved ? 'unresolved' : true });
+    const errMsg = getErrMsg(url, errPrefix, true, isUnresolved);
+    assertUsage(isUrlRedirectTarget(url) || (isUnresolved && url === '*'), errMsg);
 }
-function assertUsageUrl(url, errPrefix, { isRedirectTarget } = {}) {
-    if (url.startsWith('/'))
-        return;
+function getErrMsg(url, errPrefix, allowProtocol, allowUri) {
     let errMsg = `${errPrefix} is ${pc.string(url)} but it should start with ${pc.string('/')}`;
-    if (isRedirectTarget) {
-        if (isUrlRedirectTarget(url))
-            return;
-        errMsg += ` or a protocol (${pc.string('http://')}, ${pc.string('mailto:')}, ...)`;
-        if (isRedirectTarget === 'unresolved') {
-            if (url === '*')
-                return;
-            errMsg += `, or be ${pc.string('*')}`;
-        }
-    }
-    assertUsage(false, errMsg);
+    if (allowProtocol)
+        errMsg += ` or a protocol (e.g. ${pc.string('http://')})`;
+    if (allowUri)
+        errMsg += `, or be ${pc.string('*')}`;
+    return errMsg;
 }

package/dist/esm/utils/unique.d.ts

@@ -1,2 +1 @@
-export { unique };
-declare function unique<T>(arr: T[]): T[];
+export declare function unique<T>(arr: T[]): T[];

package/dist/esm/utils/unique.js

@@ -1,4 +1,3 @@
-export { unique };
-function unique(arr) {
+export function unique(arr) {
     return Array.from(new Set(arr));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.242",
+  "version": "0.4.243-commit-6ce9ef3",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -245,7 +245,7 @@
     "@types/picomatch": "^3.0.2",
     "@types/semver": "^7.5.8",
     "@types/source-map-support": "^0.5.10",
-    "react-streaming": "^0.4.3",
+    "react-streaming": "^0.4.10",
     "rimraf": "^5.0.5",
     "typescript": "^5.9.2",
     "vite": "^7.1.5"