vike 0.4.267 → 0.4.268-commit-ca58695

package/dist/client/runtime-client-routing/renderPageClient.js

@@ -2,6 +2,7 @@ export { renderPageClient };
 export { getRenderCount };
 export { disableClientRouting };
 export { getPageContextClient };
+export { createPageContextFromServer_experimentalRSC };
 import { assert, assertInfo, assertWarning } from '../../utils/assert.js';
 import { catchInfiniteLoop } from '../../utils/catchInfiniteLoop.js';
 import { genPromise } from '../../utils/genPromise.js';
@@ -12,7 +13,8 @@ import { isReact } from '../../utils/isReact.js';
 import { objectAssign } from '../../utils/objectAssign.js';
 import { redirectHard } from '../../utils/redirectHard.js';
 import { updateType } from '../../utils/updateType.js';
-import { getPageContextFromHooksClient, getPageContextFromHooksServer, getPageContextFromHooksClient_firstRender, getPageContextFromHooksServer_firstRender, setPageContextInitIsPassedToClient, } from './getPageContextFromHooks.js';
+import { getPageContextFromHooksClient, getPageContextFromHooksServer, getPageContextFromHooksClient_firstRender, getPageContextFromHooksServer_firstRender, setPageContextInitIsPassedToClient, processPageContextFromServer, } from './getPageContextFromHooks.js';
+import { cancelStreamedValues } from './streamedValues.js';
 import { createPageContextClient } from './createPageContextClient.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
 import { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
@@ -20,6 +22,7 @@ import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide, } from '../
 import { changeUrl, saveScrollPosition } from './history.js';
 import { addNewPageContextAborted, getPageContextAddendumAbort, isAbortError, logAbort, } from '../../shared-server-client/route/abort.js';
 import { route } from '../../shared-server-client/route/index.js';
+import { forkPageContext } from '../../shared-server-client/forkPageContext.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { isScrollPosition, setScrollPosition } from './setScrollPosition.js';
 import { scrollRestoration_initialRenderIsDone } from './scrollRestoration.js';
@@ -101,7 +104,7 @@ async function renderPageClient(renderArgs) {
         }
         // Get pageContext serialized in <script id="vike_pageContext" type="application/json">
         if (isFirstRender) {
-            const pageContextSerialized = getPageContextFromHooksServer_firstRender();
+            const pageContextSerialized = await getPageContextFromHooksServer_firstRender();
             // TO-DO/eventually: create helper assertPageContextFromHook()
             assert(!('urlOriginal' in pageContextSerialized));
             objectAssign(pageContext, pageContextSerialized);
@@ -226,8 +229,10 @@ async function renderPageClient(renderArgs) {
                     return;
                 }
             }
-            if (isRenderOutdated())
+            if (isRenderOutdated()) {
+                cancelStreamedValues(pageContextFromHooksServer, false);
                 return;
+            }
             // TO-DO/eventually: create helper assertPageContextFromHook()
             assert(!('urlOriginal' in pageContextFromHooksServer));
             objectAssign(pageContext, pageContextFromHooksServer);
@@ -308,13 +313,6 @@ async function renderPageClient(renderArgs) {
         else {
             objectAssign(pageContext, { is404: false });
         }
-        const isClientRoutable = await isClientSideRoutable(pageContext.pageId, pageContext);
-        if (isRenderOutdated())
-            return;
-        if (!isClientRoutable) {
-            redirectHard(urlOriginal);
-            return;
-        }
         if (import.meta.env.DEV || globalThis.__VIKE__IS_DEBUG) {
             assertInfo(false, `Rendering error page ${errorPageId}`, { onlyOnce: false });
         }
@@ -363,7 +361,7 @@ async function renderPageClient(renderArgs) {
         const errAbort = err;
         logAbort(err, !import.meta.env.DEV, pageContext);
         const pageContextAbort = errAbort._pageContextAbort;
-        addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort);
+        addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort, getPageContextPublicClientMinimal);
         // throw render('/some-url')
         if (pageContextAbort._urlRewrite) {
             await renderPageClient({
@@ -405,6 +403,12 @@ async function renderPageClient(renderArgs) {
             }
         };
         changeUrl(urlOriginal, overwriteLastHistoryEntry);
+        {
+            const previousPageContextBefore = globalObject.renderedPageContext?.previousPageContext;
+            // Remove previousPageContext of past pages (otherwise all the past pageContext are kept in memory)
+            if (previousPageContextBefore)
+                previousPageContextBefore.previousPageContext = null;
+        }
         globalObject.previousPageContext = pageContext;
         // There should never be concurrent onRenderClient() calls
         assert(globalObject.onRenderClientPreviousPromise === undefined);
@@ -447,6 +451,7 @@ async function renderPageClient(renderArgs) {
         // We purposely abort *after* onHydrationEnd() is called (see comment above).
         if (isRenderOutdated(true))
             return;
+        cancelStreamedValues(pageContext, true);
         // onPageTransitionEnd()
         if (globalObject.isTransitioning) {
             globalObject.isTransitioning = undefined;
@@ -491,7 +496,9 @@ async function renderPageClient(renderArgs) {
     }
 }
 async function getPageContextBegin(isForErrorPage, { urlOriginal, isBackwardNavigation, isHistoryNavigation, pageContextsAborted, isClientSideNavigation, pageContextInitClient, isFirstRender, }) {
-    const previousPageContext = globalObject.previousPageContext ?? null;
+    const previousPageContext = globalObject.previousPageContext
+        ? getPageContextPublicClient(globalObject.previousPageContext)
+        : null;
     const pageContext = await createPageContextClient(urlOriginal);
     objectAssign(pageContext, {
         isBackwardNavigation,
@@ -510,7 +517,7 @@ async function getPageContextBegin(isForErrorPage, { urlOriginal, isBackwardNavi
                 showStackTrace: true,
                 onlyOnce: true,
             });
-            return previousPageContext;
+            return this.previousPageContext;
         },
         enumerable: false,
     });
@@ -527,21 +534,12 @@ function stampFinished(urlOriginal) {
     window._vike ?? (window._vike = {});
     window._vike.fullyRenderedUrl = urlOriginal;
 }
-function disableClientRouting(err, log) {
+function disableClientRouting(err, logError) {
     globalObject.clientRoutingIsDisabled = true;
     assert(isErrorFetchingStaticAssets(err));
-    if (log) {
-        // We purposely don't use console.error() to avoid flooding error trackers such as Sentry
-        console.log(err);
-    }
-    assertInfo(false, [
-        'Failed to fetch static asset.',
-        import.meta.env.PROD ? 'This usually happens when a new frontend is deployed.' : null,
-        'Falling back to Server Routing.',
-        '(The next page navigation will use Server Routing instead of Client Routing.)',
-    ]
-        .filter(Boolean)
-        .join(' '), { onlyOnce: true });
+    if (logError)
+        console.log(err); // We purposely don't use console.error() to avoid flooding error trackers such as Sentry
+    assertInfo(false, 'Failed to fetch static asset (due to a connection issue, or a new deployment) — falling back to Server Routing', { onlyOnce: true });
 }
 function getIsRenderOutdated() {
     const renderNumber = ++globalObject.renderCounter;
@@ -581,7 +579,7 @@ function getKeepScrollPositionSetting(pageContext) {
     assert(configDefinedAt);
     const routeParameterList = getRouteStringParameterList(configDefinedAt);
     if (isCallable(val))
-        val = val(pageContext, {
+        val = val(getPageContextPublicClient(pageContext), {
             configDefinedAt: c.definedAt,
             /* We don't pass routeParameterList because it's useless: the user knows the parameter list.
             routeParameterList
@@ -618,6 +616,29 @@ function getPageContextClient() {
         return null;
     return getPageContextPublicClient(pageContext);
 }
+// TODO/soon: check whether this is the right API
+/**
+ * Creates a new `pageContext` for the page that `pageContext` renders, with the values of `pageContextFromServer` on top.
+ * - `pageContext` is the `pageContext` of the page rendered last
+ * - `pageContext` and `pageContextFromServer` aren't modified
+ * - The new `pageContext` is the `pageContext.previousPageContext` of the next navigation, including a navigation that has already started
+ * - Unless a navigation has started, `getPageContextClient()` returns the new `pageContext`
+ */
+function createPageContextFromServer_experimentalRSC(pageContext, pageContextFromServer) {
+    const pageContextFromServerCopy = { ...pageContextFromServer };
+    processPageContextFromServer(pageContextFromServerCopy);
+    const pageContextNew = forkPageContext(pageContext._originalObject);
+    objectAssign(pageContextNew, pageContextFromServerCopy);
+    // A navigation sets currentPageContext and reads previousPageContext when it starts, and sets previousPageContext when it renders
+    if (globalObject.currentPageContext === globalObject.previousPageContext) {
+        globalObject.currentPageContext = pageContextNew;
+    }
+    else {
+        globalObject.currentPageContext.previousPageContext = getPageContextPublicClient(pageContextNew);
+    }
+    globalObject.previousPageContext = pageContextNew;
+    return getPageContextPublicClient(pageContextNew);
+}
 async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated) {
     let hasErr = false;
     let err;
@@ -628,17 +649,14 @@ async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRend
     catch (err_) {
         err = err_;
         hasErr = true;
-        if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
-            return { skip: true };
-        }
-        else {
-            // Syntax error in user file
-        }
     }
     if (isRenderOutdated())
         return { skip: true };
-    if (hasErr)
+    if (hasErr) {
+        if (await handleErrorFetchingStaticAssets(err, pageContext, isFirstRender))
+            return { skip: true };
         return { err };
+    }
     objectAssign(pageContext, pageContextAddendum);
     try {
         await execHook('onCreatePageContext', pageContext, getPageContextPublicClient);
@@ -653,21 +671,109 @@ async function loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRend
         return { err };
     return { pageContext };
 }
-function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
-    if (!isErrorFetchingStaticAssets(err)) {
+async function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
+    if (import.meta.env.DEV)
         return false;
-    }
-    if (isFirstRender) {
+    if (!isErrorFetchingStaticAssets(err))
+        return false; // Syntax error in user file
+    // *******************************************
+    // ******* The three possible actions ********
+    // *******************************************
+    /** Show Vike's error page */
+    const showErrorPage = () => {
+        disableClientRouting(err, false);
+        // Vike handles the error like any other error: Vike logs it with `console.error()` and renders Vike's error page
+        return false;
+    };
+    /** Show the rendered HTML (with broken hydration) */
+    const showCurrentBrokenPage = () => {
         disableClientRouting(err, false);
-        // This may happen if the frontend was newly deployed during hydration.
-        // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
+        // Abort rendering (and don't show error page), not gracefully: the error throws (i.e. the error is handled by the browser and shown in the browser's developer console)
         throw err;
+    };
+    /** Do a full (re-)load of the page */
+    const hardReload = (url) => {
+        disableClientRouting(err, true);
+        if (url) {
+            redirectHard(url);
+        }
+        else {
+            // We use `location.reload()` instead of redirectHard(): navigating with `location.href = url` creates a `type: 'navigate'` entry, which would lead to an infinite reload loop — see isPageReload()
+            window.location.reload();
+        }
+        // Abort rendering (and don't show error page), gracefully (i.e. without throwing nor logging any error)
+        return true;
+    };
+    // **************************
+    // ******* The logic ********
+    // **************************
+    // Possible causes that lead to this point:
+    // - New deployment
+    // - Connection problem
+    // === Client-side navigation ===
+    // We hard load the next page:
+    // - New deployment => fully reloading the website is exactly what we want
+    // - Connection problem => next page isn't shown => only useful action is to try again with a hard reload
+    //   - It's usually better to show the browser's offline page than to leave the user stuck on the old page. (This way, the user knows there's a connection problem instead of wondering whether the website is broken.)
+    if (!isFirstRender) {
+        return hardReload(pageContext.urlOriginal);
+    }
+    // === First render ===
+    // Avoid infinite reload loop: we don't reload a page that was itself loaded by a reload
+    if (isPageReload()) {
+        if (isBlankPage()) {
+            return showErrorPage();
+        }
+        else {
+            return showCurrentBrokenPage();
+        }
+    }
+    if (isBlankPage()) {
+        return hardReload();
     }
     else {
-        disableClientRouting(err, true);
+        globalObject.clientRoutingIsDisabled = true; // Eagerly disable before connection check
+        if (!(await isConnectionDown())) {
+            // Most likely a new deployment (or the connection is back): either way, reloading fixes the page
+            return hardReload();
+        }
+        else {
+            // - Reloading is counterproductive since it would likely get another connection error, resulting in either: the browser's offline page, or repeating this asset loading failure.
+            // - Handling flaky connections is the browser's job (e.g. the user reloads the page)
+            // - Showing the rendered HTML is usually more useful to the user (even when unhydrated thus broken) than showing Vike's error page
+            return showCurrentBrokenPage();
+        }
     }
-    redirectHard(pageContext.urlOriginal);
-    return true;
+}
+// Whether fetching static assets fails because of the connection. (The error thrown by `import()` doesn't tell: it's the same whether a new frontend was deployed, i.e. the static assets don't exist anymore, or the connection is down.)
+async function isConnectionDown() {
+    try {
+        await fetch(window.location.href, {
+            method: 'HEAD',
+            cache: 'no-store',
+            // On a flaky connection, the request may hang and succeed much later: we don't want to reload the page long after it was shown (e.g. while the user is filling a form)
+            signal: AbortSignal.timeout(4000),
+        });
+        // The server responds
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+// The page shows nothing (e.g. SPA)
+function isBlankPage() {
+    return !document.body.innerText.trim();
+}
+// Whether the current page was loaded by a page reload
+function isPageReload() {
+    // The browser records how the current document was loaded (Navigation Timing API)
+    const navigation = performance.getEntriesByType('navigation')[0];
+    return (
+    // Cannot be determined (e.g. older browsers)
+    !navigation ||
+        // A document loaded by `location.reload()` has `type: 'reload'`
+        navigation.type === 'reload');
 }
 // [HMR] If error page is shown => re-render whole page
 if (import.meta.env.DEV && import.meta.hot)

package/dist/client/runtime-client-routing/streamedValues.d.ts

@@ -0,0 +1,5 @@
+export { readPageContextJson };
+export { cancelStreamedValues };
+import '../assertEnvClient.js';
+declare function readPageContextJson(response: Response): Promise<unknown>;
+declare function cancelStreamedValues(pageContext: object, isRendered: boolean): void;

package/dist/client/runtime-client-routing/streamedValues.js

@@ -0,0 +1,23 @@
+// Streamed pageContext values https://vike.dev/passToClient#streaming, upon client-side navigation: the decoder
+// (../shared/streamedValues.ts) is loaded only if the `.pageContext.json` response is a JSON array (see
+// server/runtime/renderPageServer/getPageContextJson.ts).
+export { readPageContextJson };
+export { cancelStreamedValues };
+import { parse } from '@brillout/json-serializer/parse';
+import '../assertEnvClient.js';
+let decoder;
+async function readPageContextJson(response) {
+    const reader = response.clone().body.getReader();
+    let chunk = await reader.read();
+    while (!chunk.done && !chunk.value.length)
+        chunk = await reader.read();
+    reader.cancel();
+    // A pageContext always serializes as `{…}`, so an array (`[` is 91) means streamed values
+    if (chunk.value?.[0] !== 91)
+        return parse(await response.text());
+    decoder ?? (decoder = await import('../shared/streamedValues.js'));
+    return decoder.readPageContextJsonStreamed(response);
+}
+function cancelStreamedValues(pageContext, isRendered) {
+    decoder?.cancelStreamedValues(pageContext, isRendered);
+}

package/dist/client/runtime-server-routing/createPageContextClient.d.ts

@@ -35,9 +35,14 @@ declare function createPageContextClient(): Promise<{
         _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & {
         isClientSide: true;
+        devMiddleware: null;
     };
     _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
 } & import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").GlobalConfigPublic>;

package/dist/client/runtime-server-routing/entry.js

@@ -23,7 +23,7 @@ if (import.meta.env.DEV)
 hydrate();
 async function hydrate() {
     const pageContext = await createPageContextClient();
-    objectAssign(pageContext, getPageContextSerializedInHtml());
+    objectAssign(pageContext, await getPageContextSerializedInHtml());
     // Sets pageContext.config using non-global configs — overrides the pageContext.config set using global configs at createPageContextClient()
     const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
     objectAssign(pageContext, pageContextAddendum);

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

@@ -25,7 +25,12 @@ declare function getGlobalContextClientInternal(): Promise<{
     _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & {
     isClientSide: true;
+    devMiddleware: null;
 }>;

package/dist/client/shared/getGlobalContextClientInternalShared.d.ts

@@ -29,6 +29,10 @@ declare function getGlobalContextClientInternalShared(): Promise<{
     _pageFilesAll: import("../../shared-server-client/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
     _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    _environmentEntries: Record<string, {
+        pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+    } | null>;
     _allPageIds: string[];
 } & {
     /**
@@ -39,6 +43,7 @@ declare function getGlobalContextClientInternalShared(): Promise<{
      * https://vike.dev/globalContext#isClientSide
      */
     isClientSide: true;
+    devMiddleware: null;
 }>;
 type TypeIsNotExported = never;
 declare function getGlobalContext(): Promise<TypeIsNotExported>;

package/dist/client/shared/getGlobalContextClientInternalShared.js

@@ -36,6 +36,8 @@ async function getGlobalContextClientInternalShared() {
              * https://vike.dev/globalContext#isClientSide
              */
             isClientSide: true,
+            // https://vike.dev/globalContext#devMiddleware
+            devMiddleware: null,
         };
         objectAssign(globalContextAddendum, getGlobalContextSerializedInHtml());
         return globalContextAddendum;

package/dist/client/shared/getJsonSerializedInHtml.d.ts

@@ -1,8 +1,8 @@
 export { getPageContextSerializedInHtml };
 export { getGlobalContextSerializedInHtml };
 import '../assertEnvClient.js';
-declare function getPageContextSerializedInHtml(): {
+declare function getPageContextSerializedInHtml(): Promise<{
     pageId: string;
     routeParams: Record<string, string>;
-};
+}>;
 declare function getGlobalContextSerializedInHtml(): object;

package/dist/client/shared/getJsonSerializedInHtml.js

@@ -9,23 +9,26 @@ import '../assertEnvClient.js';
 // 1. <script id="vike_pageContext" type="application/json"> appears before the <script> that loads Vike's client runtime (which includes this file)
 // 2. <script id="vike_pageContext" type="application/json"> is neither async nor defer
 // See https://github.com/vikejs/vike/pull/1271
-function getPageContextSerializedInHtml() {
-    const pageContextSerializedInHtml = findAndParseJson(htmlElementId_pageContext);
+async function getPageContextSerializedInHtml() {
+    const pageContextJson = findJson(htmlElementId_pageContext);
+    // A pageContext always serializes as `{…}`, so an array means streamed values https://vike.dev/passToClient#streaming
+    const pageContextSerializedInHtml = pageContextJson[0] === '['
+        ? (await import('./streamedValues.js')).parsePageContextHtml(pageContextJson)
+        : parse(pageContextJson);
     assert(hasProp(pageContextSerializedInHtml, 'pageId', 'string'));
     assert(hasProp(pageContextSerializedInHtml, 'routeParams', 'string{}'));
     return pageContextSerializedInHtml;
 }
 function getGlobalContextSerializedInHtml() {
-    const globalContextSerializedInHtml = findAndParseJson(htmlElementId_globalContext);
+    const globalContextSerializedInHtml = parse(findJson(htmlElementId_globalContext));
     return globalContextSerializedInHtml;
 }
-function findAndParseJson(id) {
+function findJson(id) {
     const elem = document.getElementById(id);
     assertUsage(elem, 
     // It seems like it can be missing when HTML is malformed: https://github.com/vikejs/vike/issues/913
     `Couldn't find #${id} (which Vike automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`);
     const jsonStr = elem.textContent;
     assert(jsonStr);
-    const json = parse(jsonStr);
-    return json;
+    return jsonStr;
 }

package/dist/client/shared/loadPageConfigsLazyClientSide.js

@@ -53,10 +53,6 @@ function isFetchError(err) {
         'error loading dynamically imported module',
         // safari
         'Importing a module script failed',
-        // ??
-        'error resolving module specifier',
-        // ??
-        'failed to resolve module',
     ];
     return FAILED_TO_FETCH_MESSAGES.some((s) => err.message.toLowerCase().includes(s.toLowerCase()));
 }

package/dist/client/shared/removeFoucBuster.js

@@ -38,9 +38,20 @@ function clean() {
         const href = linkVike.getAttribute('href');
         assert(href && href.endsWith(suffix));
         let filePathAbsoluteUserRootDir = href.slice(0, -suffix.length);
-        const prefix = '/@fs/';
-        if (filePathAbsoluteUserRootDir.startsWith(prefix))
-            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir.slice(prefix.length);
+        const prefixFs = '/@fs/';
+        if (filePathAbsoluteUserRootDir.startsWith(prefixFs))
+            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir.slice(prefixFs.length);
+        // CSS virtual module:
+        // ```js
+        // import 'virtual:some.css'
+        // ```
+        // ID becomes:
+        // ```
+        // <link href="/@id/__x00__virtual:some.css?direct" rel="stylesheet" type="text/css">
+        // ```
+        const prefixId = '/@id/';
+        if (filePathAbsoluteUserRootDir.startsWith(prefixId))
+            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir.slice(prefixId.length).replace('__x00__', '\0');
         if (injectedByVite.some((filePathAbsoluteFilesystem) => filePathAbsoluteFilesystem.endsWith(filePathAbsoluteUserRootDir))) {
             linkVike.remove();
         }

package/dist/client/shared/streamedValues/asyncIterable.d.ts

@@ -0,0 +1,4 @@
+export { asyncIterable };
+import type { StreamedValueType } from './registry.js';
+import '../../assertEnvClient.js';
+declare const asyncIterable: StreamedValueType;

package/dist/client/shared/streamedValues/asyncIterable.js

@@ -0,0 +1,26 @@
+export { asyncIterable };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { readableStream } from './readableStream.js';
+import '../../assertEnvClient.js';
+// A ReadableStream, consumed as an async iterable: `for await (const chunk of pageContext.someAsyncIterable)` (Safari's
+// ReadableStream isn't async-iterable)
+const asyncIterable = {
+    marker: markers.asyncIterable,
+    revive(parseValue) {
+        const streamedValue = readableStream.revive(parseValue);
+        return { ...streamedValue, value: toAsyncIterable(streamedValue.value) };
+    },
+};
+function toAsyncIterable(stream) {
+    const reader = stream.getReader();
+    const iterator = {
+        next: () => reader.read(),
+        // Called upon `break` in `for await`
+        async return(value) {
+            await reader.cancel();
+            return { done: true, value };
+        },
+        [Symbol.asyncIterator]: () => iterator,
+    };
+    return iterator;
+}

package/dist/client/shared/streamedValues/lines.d.ts

@@ -0,0 +1,11 @@
+export { decodeChunk };
+export { getLineError };
+import '../../assertEnvClient.js';
+declare function decodeChunk(line: {
+    t: string;
+} | {
+    b: string;
+} | {
+    v: unknown;
+}, parseValue: (value: unknown) => unknown): unknown;
+declare function getLineError(): Error;

package/dist/client/shared/streamedValues/lines.js

@@ -0,0 +1,19 @@
+// The decoding of the lines (see shared-server-client/streamedValues.ts)
+export { decodeChunk };
+export { getLineError };
+import '../../assertEnvClient.js';
+const textEncoder = new TextEncoder();
+function decodeChunk(line, parseValue) {
+    if ('t' in line)
+        return textEncoder.encode(line.t);
+    if ('b' in line)
+        return decodeBase64url(line.b);
+    return parseValue(line.v);
+}
+function getLineError() {
+    return new Error('A streamed pageContext value failed on the server-side (see the server logs)');
+}
+function decodeBase64url(str) {
+    const binary = atob(str.replaceAll('-', '+').replaceAll('_', '/'));
+    return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}

package/dist/client/shared/streamedValues/promise.d.ts

@@ -0,0 +1,4 @@
+export { promise };
+import type { StreamedValueType } from './registry.js';
+import '../../assertEnvClient.js';
+declare const promise: StreamedValueType;

package/dist/client/shared/streamedValues/promise.js

@@ -0,0 +1,19 @@
+export { promise };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { getLineError } from './lines.js';
+import { genPromise } from '../../../utils/genPromise.js';
+import '../../assertEnvClient.js';
+// Settled by its `v` or `error` line
+const promise = {
+    marker: markers.promise,
+    revive(parseValue) {
+        const { promise: value, resolve, reject } = genPromise({ timeout: null });
+        // Avoid an unhandled rejection if the user doesn't use the promise
+        value.catch(() => { });
+        return {
+            value,
+            push: (line) => ('v' in line ? resolve(parseValue(line.v)) : reject(getLineError())),
+            fail: reject,
+        };
+    },
+};

package/dist/client/shared/streamedValues/readableStream.d.ts

@@ -0,0 +1,4 @@
+export { readableStream };
+import type { StreamedValueType } from './registry.js';
+import '../../assertEnvClient.js';
+declare const readableStream: StreamedValueType;

package/dist/client/shared/streamedValues/readableStream.js

@@ -0,0 +1,44 @@
+export { readableStream };
+import { markers } from '../../../shared-server-client/streamedValues.js';
+import { decodeChunk, getLineError } from './lines.js';
+import '../../assertEnvClient.js';
+// Fed by its chunk lines, until its `end` or `error` line
+const readableStream = {
+    marker: markers.readableStream,
+    revive(parseValue) {
+        let controller;
+        let isClosed = false;
+        const value = new ReadableStream({
+            start(controller_) {
+                controller = controller_;
+            },
+            cancel() {
+                // Released by its consumer: the rest is ignored
+                isClosed = true;
+            },
+        });
+        const close = (err) => {
+            if (isClosed)
+                return;
+            isClosed = true;
+            if (err)
+                controller.error(err);
+            else
+                controller.close();
+        };
+        return {
+            value,
+            push(line) {
+                if (isClosed)
+                    return;
+                if ('end' in line)
+                    close();
+                else if ('error' in line)
+                    close(getLineError());
+                else
+                    controller.enqueue(decodeChunk(line, parseValue));
+            },
+            fail: close,
+        };
+    },
+};