vike 0.4.247 → 0.4.248

package/dist/server/runtime/renderPageServer/inferMediaType.js

@@ -0,0 +1,79 @@
+export { inferMediaType };
+import { styleFileRE, isScriptFile } from '../../utils.js';
+function inferMediaType(href) {
+    // Basics
+    if (styleFileRE.test(href)) {
+        return { mediaType: 'text/css', assetType: 'style' };
+    }
+    if (isScriptFile(href)) {
+        return { mediaType: 'text/javascript', assetType: 'script' };
+    }
+    // Images
+    if (href.endsWith('.png')) {
+        return { assetType: 'image', mediaType: 'image/png' };
+    }
+    if (href.endsWith('.webp')) {
+        return { assetType: 'image', mediaType: 'image/webp' };
+    }
+    if (href.endsWith('.jpg') || href.endsWith('.jpeg')) {
+        return { assetType: 'image', mediaType: 'image/jpeg' };
+    }
+    if (href.endsWith('.gif')) {
+        return { assetType: 'image', mediaType: 'image/gif' };
+    }
+    if (href.endsWith('.svg')) {
+        return { assetType: 'image', mediaType: 'image/svg+xml' };
+    }
+    if (href.endsWith('.avif')) {
+        return { assetType: 'image', mediaType: 'image/avif' };
+    }
+    // Fonts
+    if (href.endsWith('.ttf')) {
+        return { assetType: 'font', mediaType: 'font/ttf' };
+    }
+    if (href.endsWith('.woff')) {
+        return { assetType: 'font', mediaType: 'font/woff' };
+    }
+    if (href.endsWith('.woff2')) {
+        return { assetType: 'font', mediaType: 'font/woff2' };
+    }
+    // Videos
+    if (href.endsWith('.mp4')) {
+        return { assetType: 'video', mediaType: 'video/mp4' };
+    }
+    if (href.endsWith('.webm')) {
+        return { assetType: 'video', mediaType: 'video/webm' };
+    }
+    if (href.endsWith('.ogv')) {
+        return { assetType: 'video', mediaType: 'video/ogg' };
+    }
+    if (href.endsWith('.mpeg') || href.endsWith('.mpg')) {
+        return { assetType: 'video', mediaType: 'video/mpeg' };
+    }
+    if (href.endsWith('.avi')) {
+        return { assetType: 'video', mediaType: 'video/x-msvideo' };
+    }
+    if (href.endsWith('.mov') || href.endsWith('.qt')) {
+        return { assetType: 'video', mediaType: 'video/quicktime' };
+    }
+    // Audios
+    if (href.endsWith('.mp3')) {
+        return { assetType: 'audio', mediaType: 'audio/mpeg' };
+    }
+    if (href.endsWith('.wav')) {
+        return { assetType: 'audio', mediaType: 'audio/wav' };
+    }
+    if (href.endsWith('.ogg')) {
+        return { assetType: 'audio', mediaType: 'audio/ogg' };
+    }
+    if (href.endsWith('.m4a')) {
+        return { assetType: 'audio', mediaType: 'audio/aac' };
+    }
+    if (href.endsWith('midi') || href.endsWith('.mid')) {
+        return { assetType: 'audio', mediaType: 'audio/midi' };
+    }
+    if (href.endsWith('.flac')) {
+        return { assetType: 'audio', mediaType: 'audio/flac' };
+    }
+    return null;
+}

package/dist/server/runtime/renderPageServer/loadPageConfigsLazyServerSide.d.ts

@@ -0,0 +1,170 @@
+export { loadPageConfigsLazyServerSide };
+export type { PageContext_loadPageConfigsLazyServerSide };
+export type { PageConfigsLazy };
+export type { PageContextAfterPageEntryLoaded };
+import { type PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
+import { PromiseType } from '../../utils.js';
+import { type PageAsset } from './getPageAssets.js';
+import type { PageConfigRuntime } from '../../../types/PageConfig.js';
+import type { PassToClient } from './html/serializeContext.js';
+import type { PageContextAfterRoute } from '../../../shared-server-client/route/index.js';
+import type { PageContextCreated } from './createPageContextServerSide.js';
+type PageContext_loadPageConfigsLazyServerSide = PageContextCreated & PageContextAfterRoute & {
+    is404: boolean | null;
+    pageId: string;
+};
+type PageConfigsLazy = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
+declare function loadPageConfigsLazyServerSide(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<{
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+    _requestId: number;
+} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    _globalContext: ({
+        _globalConfigPublic: {
+            pages: {
+                [k: string]: {
+                    config: import("../../../types/index.js").ConfigResolved;
+                    _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                    _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                    _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+                } & ({
+                    route: import("../../../types/Config.js").Route;
+                    isErrorPage?: undefined;
+                } | {
+                    route?: undefined;
+                    isErrorPage: true;
+                });
+            };
+            config: import("../../../types/index.js").ConfigResolved;
+            _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        pages: {
+            [k: string]: {
+                config: import("../../../types/index.js").ConfigResolved;
+                _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../../types/index.js").ConfigResolved;
+        _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../../shared-server-client/getPageFiles.js").PageFile[];
+        _pageConfigs: PageConfigRuntime[];
+        _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+    } & (({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer | undefined;
+        viteConfig: import("vite").ResolvedConfig | undefined;
+        isClientSide: false;
+        _pageRoutes: import("../../../shared-server-client/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../../shared-server-client/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../../shared-server-client/route/loadPageRoutes.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    }) & {
+        baseServer: string;
+        baseAssets: string;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+    })) & {
+        prerenderContext: import("../../../types/index.js").PrerenderContext | undefined;
+    };
+    _pageFilesAll: import("../../../shared-server-client/getPageFiles.js").PageFile[];
+    _baseServer: string;
+    _baseAssets: string;
+    _pageContextInit: import("../renderPageServer.js").PageContextInit;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    pages: {
+        [k: string]: {
+            config: import("../../../types/index.js").ConfigResolved;
+            _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../../../types/index.js").ConfigResolved;
+    _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+} & {
+    urlParsed: import("../../utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & PageContextAfterRoute & {
+    is404: boolean | null;
+    pageId: string;
+} & {
+    _pageConfig: PageConfigRuntime | null;
+} & PageContextConfig & {
+    _pageConfig: null | PageConfigRuntime;
+} & {
+    cspNonce: string | null;
+} & {
+    Page: unknown;
+    _isHtmlOnly: boolean;
+    _passToClient: PassToClient;
+} & {
+    headersResponse: Headers;
+} & {
+    __getPageAssets: () => Promise<PageAsset[]>;
+}>;
+type PageContextAfterPageEntryLoaded = PageContext_loadPageConfigsLazyServerSide & {
+    _pageConfig: null | PageConfigRuntime;
+} & PageContextConfig;

package/dist/server/runtime/renderPageServer/loadPageConfigsLazyServerSide.js

@@ -0,0 +1,122 @@
+export { loadPageConfigsLazyServerSide };
+import { getPageFilesServerSide } from '../../../shared-server-client/getPageFiles.js';
+import { resolvePageContextConfig } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import { analyzePageClientSideInit } from '../../../shared-server-client/getPageFiles/analyzePageClientSide.js';
+import { assertUsage, assertWarning, hasProp, isArray, isObject, objectAssign, updateType, } from '../../utils.js';
+import { getPageAssets } from './getPageAssets.js';
+import { findPageConfig } from '../../../shared-server-client/page-configs/findPageConfig.js';
+import { analyzePage } from './analyzePage.js';
+import { loadAndParseVirtualFilePageEntry } from '../../../shared-server-client/page-configs/loadAndParseVirtualFilePageEntry.js';
+import { execHookServer } from './execHookServer.js';
+import { resolveHeadersResponseEarly } from './headersResponse.js';
+import { resolvePageContextCspNone } from './csp.js';
+async function loadPageConfigsLazyServerSide(pageContext) {
+    objectAssign(pageContext, {
+        _pageConfig: findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId),
+    });
+    // Load the page's + files
+    objectAssign(pageContext, await loadPageUserFiles(pageContext));
+    // Resolve new computed pageContext properties
+    updateType(pageContext, await resolvePageContext(pageContext));
+    // Execute +onCreatePageContext
+    await execHookServer('onCreatePageContext', pageContext);
+    return pageContext;
+}
+async function resolvePageContext(pageContext) {
+    const { isHtmlOnly, clientEntries, clientDependencies } = analyzePage(pageContext);
+    const passToClient = [];
+    const errMsgSuffix = ' should be an array of strings.';
+    const isV1Design = !!pageContext._pageConfig;
+    if (!isV1Design) {
+        pageContext.exportsAll.passToClient?.forEach((e) => {
+            assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsgSuffix}`);
+            passToClient.push(...e.exportValue);
+        });
+    }
+    else {
+        pageContext.from.configsCumulative.passToClient?.values.forEach((v) => {
+            const { value, definedAt } = v;
+            const errMsg = `+passToClient value defined at ${definedAt}${errMsgSuffix}`;
+            //*/ TO-DO/next-major-release: remove the passToClient once setting from the public API
+            assertUsage(isArray(value), `+passToClient value defined at ${definedAt} should be an array`);
+            const valS = value.map((el) => {
+                if (isObject(el)) {
+                    assertWarning(!('once' in el), '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).', { onlyOnce: true });
+                    assertUsage(hasProp(el, 'prop', 'string'), errMsg);
+                    return el.prop;
+                }
+                assertUsage(typeof el === 'string', errMsg);
+                return el;
+            });
+            /*/
+            assertUsage(isArrayOfStrings(value), errMsg)
+            //*/
+            passToClient.push(...valS);
+        });
+    }
+    objectAssign(pageContext, await resolvePageContextCspNone(pageContext));
+    objectAssign(pageContext, {
+        Page: pageContext.exports.Page,
+        _isHtmlOnly: isHtmlOnly,
+        _passToClient: passToClient,
+    });
+    objectAssign(pageContext, await resolveHeadersResponseEarly(pageContext));
+    objectAssign(pageContext, {
+        __getPageAssets: async () => {
+            if ('_pageAssets' in pageContext) {
+                return pageContext._pageAssets;
+            }
+            else {
+                const pageAssets = await getPageAssets(pageContext, clientDependencies, clientEntries);
+                objectAssign(pageContext, { _pageAssets: pageAssets });
+                return pageContext._pageAssets;
+            }
+        },
+    });
+    // TO-DO/next-major-release: remove
+    Object.assign(pageContext, {
+        _getPageAssets: async () => {
+            assertWarning(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preloading', {
+                onlyOnce: true,
+                showStackTrace: true,
+            });
+            const pageAssetsOldFormat = [];
+            (await pageContext.__getPageAssets()).forEach((p) => {
+                if (p.assetType === 'script' && p.isEntry) {
+                    pageAssetsOldFormat.push({
+                        src: p.src,
+                        preloadType: null,
+                        assetType: 'script',
+                        mediaType: p.mediaType,
+                    });
+                }
+                pageAssetsOldFormat.push({
+                    src: p.src,
+                    preloadType: p.assetType,
+                    assetType: p.assetType === 'style' ? 'style' : 'preload',
+                    mediaType: p.mediaType,
+                });
+            });
+            return pageAssetsOldFormat;
+        },
+    });
+    return pageContext;
+}
+async function loadPageUserFiles(pageContext) {
+    const [{ pageContextAddendum }] = await Promise.all([
+        (async () => {
+            const pageFilesServerSide = getPageFilesServerSide(pageContext._pageFilesAll, pageContext.pageId);
+            const isDev = !pageContext._globalContext._isProduction;
+            const pageConfigLoaded = !pageContext._pageConfig
+                ? null
+                : await loadAndParseVirtualFilePageEntry(pageContext._pageConfig, isDev);
+            await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
+            const pageContextAddendum = resolvePageContextConfig(pageFilesServerSide, pageConfigLoaded, pageContext._globalContext._pageConfigGlobal);
+            return { pageContextAddendum };
+        })(),
+        analyzePageClientSideInit(pageContext._globalContext._pageFilesAll, pageContext.pageId, {
+            sharedPageFilesAlreadyLoaded: true,
+        }),
+    ]);
+    return pageContextAddendum;
+}

package/dist/server/runtime/renderPageServer/log404/index.d.ts

@@ -0,0 +1,11 @@
+export { log404 };
+export { getRoutesInfo };
+import type { PageRoutes } from '../../../../shared-server-client/route/index.js';
+import type { GlobalContextServerInternal } from '../../globalContext.js';
+import type { PageContextCreated } from '../createPageContextServerSide.js';
+declare function log404(pageContext: PageContextCreated & {
+    urlPathname: string;
+    errorWhileRendering: null | Error;
+    _globalContext: GlobalContextServerInternal;
+}): void;
+declare function getRoutesInfo(pageRoutes: PageRoutes): string | null;

package/dist/server/runtime/renderPageServer/log404/index.js

@@ -0,0 +1,150 @@
+export { log404 };
+// Exported for ./index.spec.ts
+export { getRoutesInfo };
+import { noRouteMatch } from '../../../../shared-server-client/route/noRouteMatch.js';
+import { assert, assertUsage, assertInfo, compareString, stripAnsi, getTerminalWidth, truncateString, } from '../../../utils.js';
+import pc from '@brillout/picocolors';
+function log404(pageContext) {
+    const { urlPathname } = pageContext;
+    const pageRoutes = pageContext._globalContext._pageRoutes;
+    assertUsage(pageRoutes.length > 0, 'No page found.');
+    const globalContext = pageContext._globalContext;
+    if (!globalContext._isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
+        const routesInfo = getRoutesInfo(pageRoutes);
+        let msg = `URL ${pc.cyan(urlPathname)} ${noRouteMatch}`;
+        const outro = 'See https://vike.dev/routing for more information about routing.';
+        if (!routesInfo) {
+            msg = `${msg}. ${pc.dim(outro)}`;
+        }
+        else {
+            msg = `${msg}:\n${routesInfo}\n${outro}`;
+        }
+        assertInfo(false, msg, { onlyOnce: false });
+    }
+}
+function getRoutesInfo(pageRoutes) {
+    const entries = pageRoutes
+        .map((pageRoute) => {
+        let routeStr;
+        let routeTypeSrc;
+        let routeDefinedBy;
+        if (pageRoute.routeType === 'FILESYSTEM') {
+            assert(pageRoute.routeFilesystemDefinedBy);
+            routeDefinedBy = pageRoute.routeFilesystemDefinedBy;
+        }
+        else {
+            assert(pageRoute.routeDefinedAtString);
+            routeDefinedBy = pageRoute.routeDefinedAtString;
+        }
+        if (pageRoute.routeType === 'STRING') {
+            routeStr = pageRoute.routeString;
+            routeTypeSrc = 'Route String';
+        }
+        else if (pageRoute.routeType === 'FUNCTION') {
+            routeStr = String(pageRoute.routeFunction);
+            routeTypeSrc = 'Route Function';
+        }
+        else {
+            routeStr = pageRoute.routeString;
+            routeTypeSrc = 'Filesystem Route';
+        }
+        assert(routeStr && routeTypeSrc && routeDefinedBy);
+        return { routeStr, routeTypeSrc, routeDefinedBy };
+    })
+        .sort((e1, e2) => {
+        if (e1.routeTypeSrc !== 'Route Function' && e2.routeTypeSrc === 'Route Function') {
+            return -1;
+        }
+        if (e1.routeTypeSrc === 'Route Function' && e2.routeTypeSrc !== 'Route Function') {
+            return 1;
+        }
+        return compareString(e1.routeStr, e2.routeStr);
+    });
+    const linesContent = [
+        {
+            routeStr: 'ROUTE',
+            routeTypeSrc: 'TYPE',
+            routeDefinedBy: 'DEFINED BY',
+        },
+        ...entries,
+    ];
+    const terminalWidth = getTerminalWidth() || 134;
+    let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => stripAnsi(routeTypeSrc).length));
+    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => stripAnsi(routeDefinedBy).length));
+    const width1_max = terminalWidth -
+        width3 -
+        width2 -
+        // Total width of table border & padding
+        10;
+    if (width1_max < 10)
+        return null;
+    linesContent.forEach((lineContent) => {
+        let { routeStr } = lineContent;
+        if (lineContent.routeTypeSrc === 'Route Function') {
+            routeStr = truncateRouteFunction(routeStr, width1_max);
+            assert(stripAnsi(routeStr).length <= width1_max);
+        }
+        lineContent.routeStr = routeStr;
+    });
+    let width1 = Math.max(...linesContent.map(({ routeStr }) => stripAnsi(routeStr).length));
+    if (width1 > width1_max)
+        return null;
+    let lines = linesContent.map(({ routeStr, routeTypeSrc, routeDefinedBy }, i) => {
+        let cell1 = padEnd(routeStr, width1 + (stripAnsi(routeStr).length - stripAnsi(routeStr).length));
+        let cell2 = padEnd(routeTypeSrc, width2);
+        let cell3 = padEnd(routeDefinedBy, width3);
+        const isHeader = i === 0;
+        if (isHeader) {
+            cell1 = pc.dim(cell1);
+            cell2 = pc.dim(cell2);
+            cell3 = pc.dim(cell3);
+        }
+        let line = [cell1, cell2, cell3].join(pc.dim(' │ '));
+        line = pc.dim('│ ') + line + pc.dim(' │');
+        return line;
+    });
+    width1 = width1 + 2;
+    width2 = width2 + 2;
+    width3 = width3 + 2;
+    // https://en.wikipedia.org/wiki/Box-drawing_character
+    lines = [
+        pc.dim(`┌${'─'.repeat(width1)}┬${'─'.repeat(width2)}┬${'─'.repeat(width3)}┐`),
+        lines[0],
+        pc.dim(`├${'─'.repeat(width1)}┼${'─'.repeat(width2)}┼${'─'.repeat(width3)}┤`),
+        ...lines.slice(1),
+        pc.dim(`└${'─'.repeat(width1)}┴${'─'.repeat(width2)}┴${'─'.repeat(width3)}┘`),
+    ];
+    lines.forEach((line) => {
+        assert(stripAnsi(line).length <= terminalWidth);
+    });
+    return lines.join('\n');
+}
+function truncateRouteFunction(routeStr, lenMax) {
+    routeStr = stripAnsi(routeStr);
+    routeStr = removeNonAscii(routeStr);
+    routeStr = routeStr.split(/\s/).filter(Boolean).join(' ');
+    routeStr = truncateString(routeStr, lenMax);
+    return routeStr;
+}
+/** Same as String.prototype.padEnd but with stripAnsi() */
+function padEnd(str, width) {
+    const padWidth = Math.max(0, width - stripAnsi(str).length);
+    return str + ''.padEnd(padWidth, ' ');
+}
+function removeNonAscii(str) {
+    // https://stackoverflow.com/questions/20856197/remove-non-ascii-character-in-string/20856346#20856346
+    return str.replace(/[^\x00-\x7F]/g, '');
+}
+function isFileRequest(urlPathname) {
+    assert(urlPathname.startsWith('/'));
+    const paths = urlPathname.split('/');
+    const lastPath = paths[paths.length - 1];
+    assert(typeof lastPath === 'string');
+    const parts = lastPath.split('.');
+    if (parts.length < 2) {
+        return false;
+    }
+    const fileExtension = parts[parts.length - 1];
+    assert(typeof fileExtension === 'string');
+    return /^[a-z0-9]+$/.test(fileExtension);
+}

package/dist/server/runtime/renderPageServer/loggerProd.d.ts

@@ -0,0 +1,3 @@
+export { loggRuntimeErrorProd };
+import { type PageContext_logRuntime } from '../loggerRuntime.js';
+declare function loggRuntimeErrorProd(err: unknown, pageContext: PageContext_logRuntime): void;

package/dist/server/runtime/renderPageServer/loggerProd.js

@@ -0,0 +1,9 @@
+// Logger used for the production server.
+// Any other environment (dev, preview, build, and pre-rendering) uses loggerDev.ts instead.
+export { loggRuntimeErrorProd };
+import { logErrorServer } from '../logErrorServer.js';
+import { assertPageContext_logRuntime } from '../loggerRuntime.js';
+function loggRuntimeErrorProd(err, pageContext) {
+    assertPageContext_logRuntime(pageContext);
+    logErrorServer(err, pageContext);
+}

package/dist/server/runtime/renderPageServer/preparePageContextForPublicUsageServer.d.ts

@@ -0,0 +1,25 @@
+export { preparePageContextForPublicUsageServer };
+export type { PageContextForPublicUsageServer };
+export type { PageContextPublicProxyServer };
+import type { PageContextUrlInternal } from '../../../shared-server-client/getPageContextUrlComputed.js';
+import type { PageContextConfig } from '../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import type { PageContextInternalServer } from '../../../types/PageContext.js';
+import type { GlobalContextServerInternal } from '../globalContext.js';
+type PageContextForPublicUsageServer = PageContextInternalServer & PageContextConfig & {
+    urlOriginal: string;
+    /** @deprecated */
+    url: string;
+    urlPathname: string;
+    urlParsed: PageContextUrlInternal['urlParsed'];
+    routeParams: Record<string, string>;
+    Page: unknown;
+    pageId: string;
+    is404: null | boolean;
+    _globalContext: GlobalContextServerInternal;
+};
+type PageContextPublicProxyServer = ReturnType<typeof preparePageContextForPublicUsageServer>;
+declare function preparePageContextForPublicUsageServer<PageContext extends PageContextForPublicUsageServer>(pageContext: PageContext): PageContext & {
+    _isProxyObject: true;
+    _originalObject: PageContext;
+    dangerouslyUseInternals: PageContext;
+};

package/dist/server/runtime/renderPageServer/preparePageContextForPublicUsageServer.js

@@ -0,0 +1,8 @@
+export { preparePageContextForPublicUsageServer };
+import { assertPropertyGetters, preparePageContextForPublicUsage, } from '../../../shared-server-client/preparePageContextForPublicUsage.js';
+function preparePageContextForPublicUsageServer(pageContext) {
+    // TO-DO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
+    assertPropertyGetters(pageContext);
+    const pageContextPublic = preparePageContextForPublicUsage(pageContext);
+    return pageContextPublic;
+}