vike 0.4.267 → 0.4.268-commit-ca58695

package/dist/shared-server-client/hooks/execHook.d.ts

@@ -38,7 +38,7 @@ declare function execHookSingleWithReturn<PageContext extends PageContextExecHoo
 }>;
 declare function isUserHookError(err: unknown): false | HookLoc;
 declare function execHookSingleWithoutPageContext<HookReturn>(hook: Omit<HookInternal, 'hookFn'>, globalContext: GlobalContextPublicMinimum, hookFnCaller: () => HookReturn): Promise<HookReturn>;
-declare function execHookSingleSync<PageContext extends PageContextExecHook>(hook: Omit<HookInternal<PageContext>, 'hookTimeout'>, globalContext: GlobalContextPublicMinimum, pageContext: PageContext | null, getPageContextPublic: (pageContext: PageContext) => PageContext, hookFnCaller?: () => unknown): {
+declare function execHookSingleSync<PageContext extends PageContextExecHook>(hook: Omit<HookInternal<PageContext>, 'hookTimeout'>, globalContext: GlobalContextPublicMinimum, pageContext: PageContext | null, getPageContextPublic: (pageContext: PageContext) => PageContext, hookFnCaller?: (pageContextPublic: PageContext | null) => unknown): {
     hookReturn: unknown;
 };
 type HookPublic = {

package/dist/shared-server-client/hooks/execHook.js

@@ -61,8 +61,8 @@ async function execHookSingleWithoutPageContext(hook, globalContext, hookFnCalle
 }
 function execHookSingleSync(hook, globalContext, pageContext, getPageContextPublic, hookFnCaller) {
     const pageContextPublic = pageContext && getPageContextPublic(pageContext);
-    hookFnCaller ?? (hookFnCaller = () => hook.hookFn(pageContextPublic));
-    const hookReturn = execHookBase(hookFnCaller, hook, globalContext, pageContextPublic);
+    const call = hookFnCaller ? () => hookFnCaller(pageContextPublic) : () => hook.hookFn(pageContextPublic);
+    const hookReturn = execHookBase(call, hook, globalContext, pageContextPublic);
     return { hookReturn };
 }
 function execHookBaseAsync(hookFnCaller, hook, globalContext, pageContextPublic) {

package/dist/shared-server-client/page-configs/serialize/serializeConfigValues.js

@@ -207,6 +207,8 @@ function getConfigValuesBase(pageConfig, runtimeEnv, isEager) {
         assert(configDef);
         if (isEager !== null && isEager !== !!configDef.eager)
             return 'SKIP';
+        if (configDef._valueNotLoadedAtRuntime && !runtimeEnv.isConfigEnvironment)
+            return 'SKIP';
         if (!configDef.cumulative) {
             const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
             const source = sourcesRelevant[0];

package/dist/shared-server-client/route/abort.d.ts

@@ -113,7 +113,7 @@ type PageContextAborted = {
     _pageContextAbort: PageContextAbort;
 } & PageContextMin;
 declare function getPageContextAddendumAbort(pageContextsAborted: PageContextAborted[]): PageContextAbort | null;
-declare function addNewPageContextAborted(pageContextsAborted: PageContextAborted[], pageContext: PageContextMin, pageContextAbort: PageContextAbort): void;
+declare function addNewPageContextAborted<PageContext extends PageContextMin>(pageContextsAborted: PageContextAborted[], pageContext: PageContext, pageContextAbort: PageContextAbort, getPageContextPublic: (pageContext: PageContext & PageContextAborted) => PageContextAborted): void;
 type InferTwoOverloads<F extends Function> = F extends {
     (...a1: infer A1): infer R1;
     (...a0: infer A0): infer R0;

package/dist/shared-server-client/route/abort.js

@@ -189,9 +189,11 @@ function getPageContextAddendumAbort(pageContextsAborted) {
     // Sets pageContext._urlRewrite from pageContextAbort._urlRewrite
     return pageContextAbort;
 }
-function addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort) {
+function addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort, 
+// `pageContextsAborted` is exposed to users: https://vike.dev/pageContext#pageContextsAborted
+getPageContextPublic) {
     objectAssign(pageContext, { _pageContextAbort: pageContextAbort });
-    pageContextsAborted.push(pageContext);
+    pageContextsAborted.push(getPageContextPublic(pageContext));
     assertNoInfiniteAbortLoop(pageContextsAborted);
 }
 // There doesn't seem to be a way to count the number of HTTP redirects (Vike doesn't have access to the HTTP request headers/cookies)

package/dist/shared-server-client/streamedValues.d.ts

@@ -0,0 +1,22 @@
+export { markers };
+export type { Line };
+export type { LineContent };
+declare const markers: {
+    readableStream: string;
+    promise: string;
+    asyncIterable: string;
+};
+type LineContent = {
+    t: string;
+} | {
+    b: string;
+} | {
+    v: unknown;
+} | {
+    end: true;
+} | {
+    error: true;
+};
+type Line = {
+    s: number;
+} & LineContent;

package/dist/shared-server-client/streamedValues.js

@@ -0,0 +1,24 @@
+// The wire format of streamed pageContext values: a ReadableStream, a Promise or an async iterable (e.g. an async
+// generator) anywhere in a passToClient value. https://vike.dev/passToClient#streaming
+//
+// - Serialization: a marker followed by the value's id, e.g. `"!VikePromise:0"` (the serializer escapes user strings
+//   starting with `!`, so a user string can't be mistaken for a marker).
+// - Delivery: the serialized pageContext is wrapped in a JSON array (the client loads its decoder only then) followed, in
+//   the same response, by one JSON line per chunk / result:
+//   - HTML: see server/runtime/renderPageServer/html/streamedValuesHtml.ts
+//   - `.pageContext.json`: see server/runtime/renderPageServer/getPageContextJson.ts
+//
+// Lines:
+//   {"s":<id>,"t":<text>}      A chunk that is a Uint8Array of valid UTF-8
+//   {"s":<id>,"b":<base64url>} A chunk that is any other Uint8Array
+//   {"s":<id>,"v":<value>}     Any other chunk, or the value of a Promise (@brillout/json-serializer)
+//   {"s":<id>,"end":true}      The end of a ReadableStream / async iterable
+//   {"s":<id>,"error":true}    The value failed (the error is logged on the server-side and isn't sent to the client)
+//
+// A chunk or a Promise value can contain further streamed values: they get new ids and their lines follow.
+export { markers };
+const markers = {
+    readableStream: '!VikeStream:',
+    promise: '!VikePromise:',
+    asyncIterable: '!VikeAsyncIterable:',
+};

package/dist/shared-server-node/vike-environments.d.ts

@@ -0,0 +1,4 @@
+export { isEnvironmentBuiltIn };
+export { isEnvironmentNameValid };
+declare function isEnvironmentBuiltIn(environmentName: string): boolean;
+declare function isEnvironmentNameValid(environmentName: string): boolean;

package/dist/shared-server-node/vike-environments.js

@@ -0,0 +1,10 @@
+export { isEnvironmentBuiltIn };
+export { isEnvironmentNameValid };
+// Vike's built-in environments; every other environment name is an additional environment (e.g. `rsc`)
+function isEnvironmentBuiltIn(environmentName) {
+    return environmentName === 'server' || environmentName === 'client';
+}
+// `:` separates the environment name from the page ID in virtual file IDs
+function isEnvironmentNameValid(environmentName) {
+    return environmentName !== '' && !environmentName.includes(':');
+}

package/dist/shared-server-node/virtualFileId.d.ts

@@ -1,5 +1,6 @@
 export { parseVirtualFileId };
 export { generateVirtualFileId };
+export { generateVirtualFileIdAdditionalEnvironment };
 export { virtualFileIdGlobalEntryServer };
 export { virtualFileIdGlobalEntryClientSR };
 export { virtualFileIdGlobalEntryClientCR };
@@ -8,21 +9,22 @@ declare const virtualFileIdGlobalEntryClientSR = "virtual:vike:global-entry:clie
 declare const virtualFileIdGlobalEntryClientCR = "virtual:vike:global-entry:client:client-routing";
 type VirtualFileIdEntryParsed = {
     type: 'global-entry';
-    isForClientSide: boolean;
+    environmentName: string;
     isClientRouting: boolean;
 } | {
     type: 'page-entry';
-    isForClientSide: boolean;
+    environmentName: string;
     pageId: string;
     isExtractAssets: boolean;
 };
 declare function parseVirtualFileId(id: string): false | VirtualFileIdEntryParsed;
 declare function generateVirtualFileId(args: {
     type: 'global-entry';
-    isForClientSide: boolean;
-    isClientRouting: boolean;
+    environmentName: string;
+    isClientRouting?: boolean;
 } | {
     type: 'page-entry';
     pageId: string;
-    isForClientSide: boolean;
+    environmentName: string;
 }): string;
+declare function generateVirtualFileIdAdditionalEnvironment(environmentName: string): string;

package/dist/shared-server-node/virtualFileId.js

@@ -1,10 +1,12 @@
 export { parseVirtualFileId };
 export { generateVirtualFileId };
+export { generateVirtualFileIdAdditionalEnvironment };
 export { virtualFileIdGlobalEntryServer };
 export { virtualFileIdGlobalEntryClientSR };
 export { virtualFileIdGlobalEntryClientCR };
 import { extractAssetsRemoveQuery } from './extractAssetsQuery.js';
 import { assert } from '../utils/assert.js';
+import { isEnvironmentBuiltIn, isEnvironmentNameValid } from './vike-environments.js';
 import { assertIsNotBrowser } from '../utils/assertIsNotBrowser.js';
 import { removeVirtualFileIdPrefix } from '../utils/virtualFileId.js';
 assertIsNotBrowser();
@@ -18,13 +20,6 @@ const virtualFileIdGlobalEntryClientSR =
 const virtualFileIdGlobalEntryClientCR = 
 //
 'virtual:vike:global-entry:client:client-routing';
-// Page entries
-const virtualFileIdPageEntryClient = 
-//
-'virtual:vike:page-entry:client:'; // ${pageId}
-const virtualFileIdPageEntryServer = 
-//
-'virtual:vike:page-entry:server:'; //  ${pageId}
 // Virtual ID prefixes
 const virtualFileIdPageEntryPrefix = 
 //
@@ -38,11 +33,11 @@ function parseVirtualFileId(id) {
         return false;
     // Global entry
     if (id.includes(virtualFileIdGlobalEntryPrefix)) {
-        const isForClientSide = id !== virtualFileIdGlobalEntryServer;
         const isClientRouting = id === virtualFileIdGlobalEntryClientCR;
+        const environmentName = parseGlobalEntryEnvironmentName(id);
         return {
             type: 'global-entry',
-            isForClientSide,
+            environmentName,
             isClientRouting,
         };
     }
@@ -51,52 +46,57 @@ function parseVirtualFileId(id) {
         const idOriginal = id;
         id = extractAssetsRemoveQuery(id);
         const isExtractAssets = idOriginal !== id;
-        if (id.startsWith(virtualFileIdPageEntryClient)) {
+        const environmentNameBegin = virtualFileIdPageEntryPrefix.length;
+        const environmentNameEnd = id.indexOf(':', environmentNameBegin);
+        assert(environmentNameEnd > environmentNameBegin);
+        const environmentName = id.slice(environmentNameBegin, environmentNameEnd);
+        const pageIdSerialized = id.slice(environmentNameEnd + 1);
+        const pageId = deserializePageId(pageIdSerialized);
+        if (environmentName === 'client')
             assert(isExtractAssets === false);
-            const pageIdSerialized = id.slice(virtualFileIdPageEntryClient.length);
-            const pageId = deserializePageId(pageIdSerialized);
-            return {
-                type: 'page-entry',
-                pageId,
-                isForClientSide: true,
-                isExtractAssets,
-            };
-        }
-        if (id.startsWith(virtualFileIdPageEntryServer)) {
-            const pageIdSerialized = id.slice(virtualFileIdPageEntryServer.length);
-            const pageId = deserializePageId(pageIdSerialized);
-            return {
-                type: 'page-entry',
-                pageId,
-                isForClientSide: false,
-                isExtractAssets,
-            };
-        }
-        assert(false);
+        return {
+            type: 'page-entry',
+            environmentName,
+            pageId,
+            isExtractAssets,
+        };
     }
     return false;
 }
+function parseGlobalEntryEnvironmentName(id) {
+    if (id === virtualFileIdGlobalEntryServer)
+        return 'server';
+    if (id === virtualFileIdGlobalEntryClientSR || id === virtualFileIdGlobalEntryClientCR)
+        return 'client';
+    const environmentName = id.slice(virtualFileIdGlobalEntryPrefix.length);
+    assert(isEnvironmentNameValid(environmentName));
+    return environmentName;
+}
 function generateVirtualFileId(args) {
     if (args.type === 'global-entry') {
-        const { isForClientSide, isClientRouting } = args;
-        if (!isForClientSide) {
-            return virtualFileIdGlobalEntryServer;
-        }
-        else if (isClientRouting) {
-            return virtualFileIdGlobalEntryClientCR;
-        }
-        else {
-            return virtualFileIdGlobalEntryClientSR;
+        const { environmentName, isClientRouting } = args;
+        assert(isEnvironmentNameValid(environmentName));
+        if (environmentName === 'client') {
+            return isClientRouting ? virtualFileIdGlobalEntryClientCR : virtualFileIdGlobalEntryClientSR;
         }
+        assert(!isClientRouting);
+        if (environmentName === 'server')
+            return virtualFileIdGlobalEntryServer;
+        return `${virtualFileIdGlobalEntryPrefix}${environmentName}`;
     }
     if (args.type === 'page-entry') {
-        const { pageId, isForClientSide } = args;
+        const { pageId, environmentName } = args;
         const pageIdSerialized = serializePageId(pageId);
-        const id = `${isForClientSide ? virtualFileIdPageEntryClient : virtualFileIdPageEntryServer}${pageIdSerialized}`;
-        return id;
+        assert(isEnvironmentNameValid(environmentName));
+        return `${virtualFileIdPageEntryPrefix}${environmentName}:${pageIdSerialized}`;
     }
     assert(false);
 }
+// The global entry of an additional environment (e.g. `rsc`)
+function generateVirtualFileIdAdditionalEnvironment(environmentName) {
+    assert(!isEnvironmentBuiltIn(environmentName));
+    return generateVirtualFileId({ type: 'global-entry', environmentName });
+}
 // Workaround:
 // - We replace virtual:vike:page-entry:client:/ with virtual:vike:page-entry:client:ROOT
 // - In order to avoid Vite to replace `virtual:vike:page-entry:client:/` with `virtual:vike:page-entry:client:`

package/dist/types/Config.d.ts

@@ -211,7 +211,7 @@ type OnRenderHtmlAsync = (pageContext: PageContextServer) => Promise<OnRenderHtm
  * - https://vike.dev/onRenderHtml
  */
 type OnRenderHtmlSync = (pageContext: PageContextServer) => OnRenderHtmlReturn;
-type OnRenderHtmlReturn = DocumentHtml | {
+type OnRenderHtmlReturn = DocumentHtml | void | {
     injectFilter?: (assets: InjectFilterEntry[]) => void;
     documentHtml?: DocumentHtml;
     pageContext?: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);
@@ -540,9 +540,9 @@ type ConfigBuiltIn = {
      *
      * The middlewares defined via `+middleware` are so called "Universal Middleware" — they work with any JavaScript server (Hono, Express, Cloudflare, ...).
      *
-     * https://github.com/magne4000/universal-middleware
+     * https://vike.dev/middleware
      */
-    middleware?: EnhancedMiddleware | EnhancedMiddleware[];
+    middleware?: EnhancedMiddleware | EnhancedMiddleware[] | ImportStringList;
     /**
      * Set to `false` to disable Vike's automatic server integration mechanism (e.g. for integrating a JavaScript server manually via `renderPage()`).
      *
@@ -551,6 +551,14 @@ type ConfigBuiltIn = {
      * https://vike.dev/server
      */
     server?: boolean | ImportStringList;
+    /**
+     * Control how your server starts.
+     *
+     * It's built into `dist/server/index.mjs` for production, and it's also run in development if you don't define `+server.js`.
+     *
+     * https://vike.dev/serverEntry
+     */
+    serverEntry?: string | ImportStringList;
     /**
      * Set to `true` to create `.br` and `.gz` files for your static assets at build time, so that they don't have to be compressed on each request.
      *

package/dist/types/GlobalContext.d.ts

@@ -7,12 +7,12 @@ import type { GlobalContextClientInternalWithServerRouting } from '../client/run
 import type { GlobalContextBasePublic } from '../shared-server-client/createGlobalContextShared.js';
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
 type GlobalContext = GlobalContextServer | GlobalContextClient;
-type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'isClientSide'> & {
+type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'middlewares' | 'isClientSide' | 'devMiddleware'> & {
     /** https://vike.dev/warning/internals */
     dangerouslyUseInternals: GlobalContextServerInternal;
 } & Vike.GlobalContext & Vike.GlobalContextServer;
 type GlobalContextClient = GlobalContextBasePublic & {
     /** https://vike.dev/warning/internals */
     dangerouslyUseInternals: GlobalContextClientInternal;
-} & Pick<GlobalContextClientInternal, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
-type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+} & Pick<GlobalContextClientInternal, 'isClientSide' | 'devMiddleware'> & Vike.GlobalContext & Vike.GlobalContextClient & {};
+type GlobalContextClientWithServerRouting = GlobalContextBasePublic & Pick<GlobalContextClientInternalWithServerRouting, 'isClientSide' | 'devMiddleware'> & Vike.GlobalContext & Vike.GlobalContextClient & {};

package/dist/types/PageConfig.d.ts

@@ -78,19 +78,27 @@ type VirtualFileExportsPageEntry = {
  *
  * https://vike.dev/meta
  */
-type ConfigEnv = ({
+type ConfigEnv = {
     /** Load value on the client-side */
     client?: boolean;
-} | {
-    /** @experimental */
-    client?: 'if-client-routing';
-}) & {
     /** Load value on the server-side */
     server?: boolean;
     /** Load value for config files */
     config?: boolean;
     /** Load value only in production (`true`), or only in development (`false`), or always (`undefined`). */
     production?: boolean;
+    /** Load value on the client-side only if the page uses Client Routing
+     *
+     * @experimental
+     */
+    clientRoutingOnly?: boolean;
+    /** Load value in an additional Vike environment, e.g. `rsc`
+     *
+     * @experimental
+     *
+     * https://vike.dev/meta#vike-environments
+     */
+    [environmentName: string]: boolean | undefined;
 };
 type ConfigValueSources = Record<string, // configName
 ConfigValueSource[]>;

package/dist/types/PageContext.d.ts

@@ -1,4 +1,3 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
 export type { PageContext };
 export type { PageContextServer };
 export type { PageContextClient };
@@ -8,7 +7,6 @@ export type { PageContextInternalServer };
 export type { PageContextInternalClient };
 export type { PageContextInternalClient_ServerRouting };
 export type { PageContextInternalClient_ClientRouting };
-export type { PageContextInitInternal };
 export type { PageContextInit };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
@@ -27,11 +25,19 @@ import type { PageContextPublicProxyClient } from '../client/runtime-client-rout
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & {
     /** https://vike.dev/warning/internals */
     dangerouslyUseInternals: DangerouslyUseInternals<PageContextInternalServer & PageContextAfterRender & PageContextPublicServer>;
-} & Vike.PageContext & Vike.PageContextServer & (Vike.Server extends {
+} & Vike.PageContext & Vike.PageContextServer & PageContextContent & (Vike.Server extends {
     server: string;
 } ? {
     runtime: RuntimeAdapterTarget<Vike.Server['server']>;
 } & PageContextReqResAlias<Vike.Server['server']> : {});
+type PageContextContent = {
+    /**
+     * The content of a non-HTML page — the HTTP response body (SSR) or the file content (pre-rendering).
+     *
+     * https://vike.dev/pageContext#content
+     */
+    content?: string | Uint8Array | ReadableStream<Uint8Array>;
+};
 type PageContextReqResAlias<Server extends string> = ReqResAlias<'req', RuntimeAdapterTarget<Server>> & ReqResAlias<'res', RuntimeAdapterTarget<Server>>;
 type ReqResAlias<Key extends 'req' | 'res', Runtime> = Key extends keyof (Vike.PageContext & Vike.PageContextServer) ? unknown : Key extends keyof Runtime ? Record<Key, Runtime[Key]> : unknown;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
@@ -141,13 +147,6 @@ type PageContextInit = {
     headersOriginal?: unknown;
     /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
 };
-type PageContextInitInternal = PageContextInit & {
-    _nodeDev?: {
-        req: IncomingMessage;
-        res: ServerResponse;
-    };
-    _reqWeb?: Request;
-};
 type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextInit & PageContextUrlServer & {
     /**
      * The HTTP request headers.
@@ -194,6 +193,15 @@ type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageConte
      * https://vike.dev/pageContext#pageContextsAborted
      */
     pageContextsAborted: Partial<PageContextServer<Data>>[];
+    /**
+     * @experimental
+     *
+     * https://vike.dev/meta#vike-environments
+     */
+    environments?: Record<string, {
+        config: PageContextConfig['config'];
+        pageContext: PageContextServer<Data>;
+    }>;
     isHydration?: undefined;
     isBackwardNavigation?: undefined;
     isHistoryNavigation?: undefined;

package/dist/types/PageContext.js

@@ -1 +1,2 @@
+// Public usage
 export {};

package/dist/types/Server.d.ts

@@ -5,7 +5,7 @@ import type { Fetchable, ServerOptions } from '@universal-deploy/store';
  *
  * https://vike.dev/server
  */
-interface Server extends Fetchable {
+interface Server extends Partial<Fetchable> {
     prod?: Omit<ServerOptions, 'fetch'> & {
         static?: boolean | string;
     };

package/dist/types/VikeNamespace.d.ts

@@ -62,7 +62,7 @@ declare global {
         }
         /** Defines the type of `pageContext.runtime`.
          *
-         *  https://vike.dev/server#pagecontext-runtime
+         *  https://vike.dev/pageContext#runtime
          */
         interface Server {
             _interfaceIsNotAny?: never;

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../../vike-server.d.ts" preserve="true" />
 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';

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: '0.4.267';
+export declare const PROJECT_VERSION: '0.4.268-commit-ca58695';

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.267';
+export const PROJECT_VERSION = '0.4.268-commit-ca58695';

package/dist/utils/assertViteVersion.d.ts

@@ -1,4 +1,2 @@
 export { assertViteVersion };
-export { viteVersionMin };
-declare const viteVersionMin = "6.3.0";
-declare function assertViteVersion(viteVersion: string): void;
+declare function assertViteVersion(viteVersion: string | undefined): void;

package/dist/utils/assertViteVersion.js

@@ -1,14 +1,11 @@
 export { assertViteVersion };
-export { viteVersionMin };
+import { assertUsage } from './assert.js';
 import { assertVersion } from './assertVersion.js';
-const viteVersionMin = '6.3.0';
-// package.json#peerDependencies isn't enough, as users often ignore it
+const viteVersionMin = '7.1.0';
+// - package.json#peerDependencies isn't enough, as users often ignore it
+// - `import { version } from 'vite'` isn't reliable: the user may still use an older Vite version — see https://github.com/vitejs/vite/pull/19355
 function assertViteVersion(viteVersion) {
-    // - This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
-    //   - TO-DO/eventually: let's also use this.meta.viteVersion
-    //     - this.meta.viteVersion was released in vite@7.0.0 => let's use it only after Vike requires a Vite version above 7.0.0
-    //     - https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#700-2025-06-24
-    //     - https://github.com/vitejs/vite/pull/20088
-    //     - We can then remove the assertUsage() at isViteServerSide.ts — see viteVersionMin export usage
+    // `viteVersion` is `undefined` on Vite 6 and older (their `config` hook has no `this`); assertVersion() needs a string
+    assertUsage(viteVersion, `You're using an old Vite version — update Vite to ${viteVersionMin} or above.`);
     assertVersion('Vite', viteVersion, [viteVersionMin]);
 }

package/dist/utils/catchInfiniteLoop.js

@@ -1,20 +1,40 @@
 export { catchInfiniteLoop };
-import { assertUsage, assertWarning } from './assert.js';
+import { assert, assertUsage, assertWarning } from './assert.js';
 import { humanizeTime } from './humanizeTime.js';
-const trackers = {};
+const trackers = new Map();
+let lastCleanup;
+// Given these parameters, a warning is shown upon 10 calls a second on average during 5 seconds
 const maxCalls = 99;
 const time = 5 * 1000;
 function catchInfiniteLoop(functionName) {
     // Init
     const now = new Date().getTime();
-    // Clean all outdated trackers
-    Object.keys(trackers).forEach((key) => {
-        const tracker = trackers[key];
-        const elapsedTime = now - tracker.startTime;
-        if (elapsedTime > time)
-            delete trackers[key];
-    });
-    const tracker = (trackers[functionName] ?? (trackers[functionName] = { count: 0, startTime: now }));
+    // Cleanup
+    if (globalThis.__VIKE__IS_CLIENT) {
+        // No cleanup on the client-side, in order to minimize client-side JavaScript (to save client-side KBs)
+        assert(trackers.size < 5);
+    }
+    else {
+        // Clean outdated trackers
+        // - On the server-side, there is an infinite amount of outdated trackers (a new tracker is created per HTTP request) => we should clean them
+        // - We don't clean upon every call: the server creates a new tracker per HTTP request, so that would cost O(n^2) — O(number of requests within `time`) per request
+        //   - https://github.com/vikejs/vike/pull/3576
+        const cleanInterval = 10 * 1000;
+        lastCleanup ?? (lastCleanup = now);
+        if (now - lastCleanup > cleanInterval) {
+            trackers.forEach((tracker, key) => {
+                if (isOutdated(tracker, now))
+                    trackers.delete(key);
+            });
+            lastCleanup = now;
+        }
+    }
+    // Get/reset tracker
+    let tracker = trackers.get(functionName);
+    if (!tracker || isOutdated(tracker, now)) {
+        tracker = { count: 0, startTime: now };
+        trackers.set(functionName, tracker);
+    }
     // Count
     tracker.count++;
     // Error
@@ -24,8 +44,10 @@ function catchInfiniteLoop(functionName) {
     }
     // Warning, at 50% threshold
     if (!tracker.warned && tracker.count > maxCalls * 0.5) {
-        // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
         assertWarning(false, msg, { onlyOnce: false, showStackTrace: true });
         tracker.warned = true;
     }
 }
+function isOutdated(tracker, now) {
+    return now - tracker.startTime > time;
+}

package/dist/utils/deepEqual.d.ts

@@ -1 +1,2 @@
-export declare function deepEqual(x: any, y: any): boolean;
+export { deepEqual };
+declare function deepEqual(x: any, y: any): boolean;

package/dist/utils/deepEqual.js

@@ -1,7 +1,22 @@
-// https://stackoverflow.com/questions/201183/how-to-determine-equality-for-two-javascript-objects/32922084#32922084
-export function deepEqual(x, y) {
-    const ok = Object.keys, tx = typeof x, ty = typeof y;
-    return x && y && tx === 'object' && tx === ty
-        ? ok(x).length === ok(y).length && ok(x).every((key) => deepEqual(x[key], y[key]))
-        : x === y;
+export { deepEqual };
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+// If client-side needs it then use a more minimal version to save client-side KBs:
+// https://github.com/vikejs/vike/blob/165d572a5994ccd0e56e43fe2993b1cef117ee7f/packages/vike/src/utils/deepEqual.ts
+assertIsNotBrowser();
+function deepEqual(x, y) {
+    return deepEqualCyclic(x, y, new Map());
+}
+// Supports cyclic objects, e.g. Vite plugins
+function deepEqualCyclic(x, y, seen) {
+    if (x === y)
+        return true;
+    if (!x || !y || typeof x !== 'object' || typeof y !== 'object')
+        return false;
+    // A pair seen before is either being compared higher up (a cycle) or already found equal
+    const seenY = seen.get(x) ?? new Set();
+    if (seenY.has(y))
+        return true;
+    seen.set(x, seenY.add(y));
+    const keys = Object.keys(x);
+    return keys.length === Object.keys(y).length && keys.every((key) => deepEqualCyclic(x[key], y[key], seen));
 }

package/dist/utils/getContentTypeFromUrl.d.ts

@@ -0,0 +1,2 @@
+export { getContentTypeFromUrl };
+declare function getContentTypeFromUrl(url: string): string | null;