vike 0.4.267-commit-b005535 → 0.4.267-commit-5676e14

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

@@ -1,6 +1,5 @@
 export { renderPageServerAfterRoute };
 export { prerenderPage };
-export { prerenderPageEntry };
 export type { PageContextAfterRender };
 import { type PageContextUrlInternal } from '../../../shared-server-client/getPageContextUrlComputed.js';
 import { HttpResponse } from './createHttpResponse.js';
@@ -21,7 +20,155 @@ declare function renderPageServerAfterRoute<PageContext extends {
     _requestId: number;
 } & PageContextCreatedServer & PageContextBegin & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
 declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry>[0]): Promise<{
+    documentHtml: null;
+    content: string | Uint8Array<ArrayBufferLike>;
+    pageContextSerialized: null;
+    pageContext: {
+        _isOriginalObject: true;
+        isPageContext: true;
+    } & {
+        isClientSide: false;
+        isPrerendering: boolean;
+        _requestId: number;
+    } & import("../renderPageServer.js").PageContextInit & {
+        _nodeDev?: {
+            req: import("http").IncomingMessage;
+            res: import("http").ServerResponse;
+        };
+        _reqWeb?: Request;
+    } & {
+        _globalContext: ({
+            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]: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
+            };
+            _globalConfigPublic: {
+                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]: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
+                };
+            };
+            isGlobalContext: true;
+            _isOriginalObject: true;
+            _virtualFileExportsGlobalEntry: unknown;
+            _pageFilesAll: import("../../__internal/index.js").PageFile[];
+            _pageConfigs: import("../../__internal/index.js").PageConfig[];
+            _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            _environmentEntries: Record<string, {
+                pageConfigs: import("../../__internal/index.js").PageConfig[];
+                pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            } | null>;
+            _allPageIds: string[];
+        } & (({
+            isClientSide: false;
+            _pageRoutes: import("../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").HookInternal | null;
+            _isProduction: false;
+            _isPrerendering: false;
+            assetsManifest: null;
+            _viteDevServer: import("vite").ViteDevServer | undefined;
+            viteConfig: import("vite").ResolvedConfig | undefined;
+        } | {
+            isClientSide: false;
+            _pageRoutes: import("../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").HookInternal | null;
+            _isProduction: true;
+            assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+            _viteDevServer: null;
+            _usesClientRouter: boolean;
+            _isPrerendering: true;
+            viteConfig: import("vite").ResolvedConfig;
+        } | {
+            isClientSide: false;
+            _pageRoutes: import("../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").HookInternal | null;
+            _isProduction: true;
+            assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+            _viteDevServer: null;
+            _usesClientRouter: boolean;
+            _isPrerendering: false;
+            viteConfig: 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("../../__internal/index.js").PageFile[];
+        _baseServer: string;
+        _baseAssets: string;
+        _pageContextInit: import("../renderPageServer.js").PageContextInit & {
+            _nodeDev?: {
+                req: import("http").IncomingMessage;
+                res: import("http").ServerResponse;
+            };
+            _reqWeb?: Request;
+        } & {
+            headers?: Record<string, unknown>;
+        };
+        _urlHandler: ((url: string) => string) | null;
+        isClientSideNavigation: boolean;
+    } & {
+        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]: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
+        };
+    } & {
+        urlParsed: import("../../../utils/parseUrl.js").UrlPublic;
+        urlPathname: string;
+        url: string;
+    } & {
+        headers: Record<string, string> | null;
+    } & import("../../../shared-server-client/route/index.js").PageContextAfterRoute & {
+        is404: boolean | null;
+        pageId: string;
+    } & {
+        _pageConfig: import("../../__internal/index.js").PageConfig | null;
+    } & import("../../../shared-server-client/getPageFiles.js").PageContextConfig & {
+        _pageConfig: null | import("../../__internal/index.js").PageConfig;
+    } & {
+        cspNonce: string | null;
+    } & {
+        Page: unknown;
+        _isHtmlOnly: boolean;
+        _passToClient: import("./html/serializeContext.js").PassToClient;
+    } & {
+        headersResponse: Headers;
+    } & {
+        __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
+    } & {
+        routeParams: Record<string, string>;
+        pageId: string;
+        _requestId: number;
+        _usesClientRouter: boolean;
+        _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+        is404: boolean;
+    } & {
+        _isPageContextJsonRequest: null;
+        pageContextsAborted: never[];
+    };
+} | {
     documentHtml: string;
+    content: null;
     pageContextSerialized: null;
     pageContext: {
         _isOriginalObject: true;
@@ -60,6 +207,10 @@ declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry
             _pageFilesAll: import("../../__internal/index.js").PageFile[];
             _pageConfigs: import("../../__internal/index.js").PageConfig[];
             _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            _environmentEntries: Record<string, {
+                pageConfigs: import("../../__internal/index.js").PageConfig[];
+                pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            } | null>;
             _allPageIds: string[];
         } & (({
             isClientSide: false;
@@ -164,6 +315,7 @@ declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry
     };
 } | {
     documentHtml: string;
+    content: null;
     pageContextSerialized: string;
     pageContext: {
         _isOriginalObject: true;
@@ -202,6 +354,10 @@ declare function prerenderPage(pageContext: Parameters<typeof prerenderPageEntry
             _pageFilesAll: import("../../__internal/index.js").PageFile[];
             _pageConfigs: import("../../__internal/index.js").PageConfig[];
             _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            _environmentEntries: Record<string, {
+                pageConfigs: import("../../__internal/index.js").PageConfig[];
+                pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            } | null>;
             _allPageIds: string[];
         } & (({
             isClientSide: false;
@@ -313,7 +469,155 @@ declare function prerenderPageEntry(pageContext: PageContextCreatedServer & Page
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
     is404: boolean;
 }): Promise<{
+    documentHtml: null;
+    content: string | Uint8Array<ArrayBufferLike>;
+    pageContextSerialized: null;
+    pageContext: {
+        _isOriginalObject: true;
+        isPageContext: true;
+    } & {
+        isClientSide: false;
+        isPrerendering: boolean;
+        _requestId: number;
+    } & import("../renderPageServer.js").PageContextInit & {
+        _nodeDev?: {
+            req: import("http").IncomingMessage;
+            res: import("http").ServerResponse;
+        };
+        _reqWeb?: Request;
+    } & {
+        _globalContext: ({
+            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]: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
+            };
+            _globalConfigPublic: {
+                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]: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
+                };
+            };
+            isGlobalContext: true;
+            _isOriginalObject: true;
+            _virtualFileExportsGlobalEntry: unknown;
+            _pageFilesAll: import("../../__internal/index.js").PageFile[];
+            _pageConfigs: import("../../__internal/index.js").PageConfig[];
+            _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            _environmentEntries: Record<string, {
+                pageConfigs: import("../../__internal/index.js").PageConfig[];
+                pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            } | null>;
+            _allPageIds: string[];
+        } & (({
+            isClientSide: false;
+            _pageRoutes: import("../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").HookInternal | null;
+            _isProduction: false;
+            _isPrerendering: false;
+            assetsManifest: null;
+            _viteDevServer: import("vite").ViteDevServer | undefined;
+            viteConfig: import("vite").ResolvedConfig | undefined;
+        } | {
+            isClientSide: false;
+            _pageRoutes: import("../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").HookInternal | null;
+            _isProduction: true;
+            assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+            _viteDevServer: null;
+            _usesClientRouter: boolean;
+            _isPrerendering: true;
+            viteConfig: import("vite").ResolvedConfig;
+        } | {
+            isClientSide: false;
+            _pageRoutes: import("../../__internal/index.js").PageRoutes;
+            _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").HookInternal | null;
+            _isProduction: true;
+            assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+            _viteDevServer: null;
+            _usesClientRouter: boolean;
+            _isPrerendering: false;
+            viteConfig: 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("../../__internal/index.js").PageFile[];
+        _baseServer: string;
+        _baseAssets: string;
+        _pageContextInit: import("../renderPageServer.js").PageContextInit & {
+            _nodeDev?: {
+                req: import("http").IncomingMessage;
+                res: import("http").ServerResponse;
+            };
+            _reqWeb?: Request;
+        } & {
+            headers?: Record<string, unknown>;
+        };
+        _urlHandler: ((url: string) => string) | null;
+        isClientSideNavigation: boolean;
+    } & {
+        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]: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").PageConfigPublicWithRoute;
+        };
+    } & {
+        urlParsed: import("../../../utils/parseUrl.js").UrlPublic;
+        urlPathname: string;
+        url: string;
+    } & {
+        headers: Record<string, string> | null;
+    } & import("../../../shared-server-client/route/index.js").PageContextAfterRoute & {
+        is404: boolean | null;
+        pageId: string;
+    } & {
+        _pageConfig: import("../../__internal/index.js").PageConfig | null;
+    } & import("../../../shared-server-client/getPageFiles.js").PageContextConfig & {
+        _pageConfig: null | import("../../__internal/index.js").PageConfig;
+    } & {
+        cspNonce: string | null;
+    } & {
+        Page: unknown;
+        _isHtmlOnly: boolean;
+        _passToClient: import("./html/serializeContext.js").PassToClient;
+    } & {
+        headersResponse: Headers;
+    } & {
+        __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
+    } & {
+        routeParams: Record<string, string>;
+        pageId: string;
+        _requestId: number;
+        _usesClientRouter: boolean;
+        _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+        is404: boolean;
+    } & {
+        _isPageContextJsonRequest: null;
+        pageContextsAborted: never[];
+    };
+} | {
     documentHtml: string;
+    content: null;
     pageContextSerialized: null;
     pageContext: {
         _isOriginalObject: true;
@@ -352,6 +656,10 @@ declare function prerenderPageEntry(pageContext: PageContextCreatedServer & Page
             _pageFilesAll: import("../../__internal/index.js").PageFile[];
             _pageConfigs: import("../../__internal/index.js").PageConfig[];
             _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            _environmentEntries: Record<string, {
+                pageConfigs: import("../../__internal/index.js").PageConfig[];
+                pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            } | null>;
             _allPageIds: string[];
         } & (({
             isClientSide: false;
@@ -456,6 +764,7 @@ declare function prerenderPageEntry(pageContext: PageContextCreatedServer & Page
     };
 } | {
     documentHtml: string;
+    content: null;
     pageContextSerialized: string;
     pageContext: {
         _isOriginalObject: true;
@@ -494,6 +803,10 @@ declare function prerenderPageEntry(pageContext: PageContextCreatedServer & Page
             _pageFilesAll: import("../../__internal/index.js").PageFile[];
             _pageConfigs: import("../../__internal/index.js").PageConfig[];
             _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            _environmentEntries: Record<string, {
+                pageConfigs: import("../../__internal/index.js").PageConfig[];
+                pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+            } | null>;
             _allPageIds: string[];
         } & (({
             isClientSide: false;

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

@@ -1,15 +1,16 @@
 export { renderPageServerAfterRoute };
 export { prerenderPage };
-export { prerenderPageEntry };
 import { getErrorPageId } from '../../../shared-server-client/error-page.js';
 import { getHtmlString } from './html/renderHtml.js';
+import { isStreamReadableWeb, streamReadableWebToBytes } from './html/stream.js';
 import { assert, assertUsage } from '../../../utils/assert.js';
 import { hasProp } from '../../../utils/hasProp.js';
 import { isSameErrorMessage } from '../../../utils/isSameErrorMessage.js';
 import { objectAssign } from '../../../utils/objectAssign.js';
 import { updateType } from '../../../utils/updateType.js';
-import { getPageContextClientSerialized } from './html/serializeContext.js';
-import { createHttpResponsePage, createHttpResponsePageJson } from './createHttpResponse.js';
+import { getStreamedValuesLinesPrerendered } from './html/streamedValuesHtml.js';
+import { getPageContextJson, getPageContextJsonFile } from './getPageContextJson.js';
+import { createHttpResponsePageHtml, createHttpResponsePageContent, createHttpResponsePageJson, } from './createHttpResponse.js';
 import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
 import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
 import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
@@ -50,14 +51,14 @@ async function renderPageServerAfterRoute(pageContext) {
         if (isError) {
             objectAssign(pageContext, { [isServerSideError]: true });
         }
-        const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
-        const httpResponse = await createHttpResponsePageJson(pageContextSerialized);
+        const httpResponse = await createHttpResponsePageJson(getPageContextJson(pageContext), pageContext);
         objectAssign(pageContext, { httpResponse });
         return pageContext;
     }
-    const renderHookResult = await execHookOnRenderHtml(pageContext);
-    const { htmlRender, renderHook } = renderHookResult;
-    const httpResponse = await createHttpResponsePage(htmlRender, renderHook, pageContext);
+    const { htmlRender, content, renderHook } = await execHookOnRenderHtml(pageContext);
+    const httpResponse = content !== null
+        ? createHttpResponsePageContent(content, renderHook, pageContext)
+        : await createHttpResponsePageHtml(htmlRender, renderHook, pageContext);
     objectAssign(pageContext, { httpResponse });
     return pageContext;
 }
@@ -85,15 +86,23 @@ async function prerenderPageEntry(pageContext) {
     await execHookGuard(pageContext, (pageContext) => getPageContextPublicServer(pageContext))
     */
     await execHookDataAndOnBeforeRender(pageContext);
-    const { htmlRender, renderHook } = await execHookOnRenderHtml(pageContext);
+    const { htmlRender, content, renderHook } = await execHookOnRenderHtml(pageContext);
+    if (content !== null) {
+        // Rejects if the stream errors
+        const fileContent = isStreamReadableWeb(content) ? await streamReadableWebToBytes(content) : content;
+        return { documentHtml: null, content: fileContent, pageContextSerialized: null, pageContext };
+    }
     assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
     const documentHtml = await getHtmlString(htmlRender);
     assert(typeof documentHtml === 'string');
+    // The streamed pageContext values were read while rendering the HTML: the same lines go into `index.pageContext.json`, and
+    // a value that failed makes pre-rendering fail (also without Client Routing)
+    const streamedValuesLines = await getStreamedValuesLinesPrerendered(pageContext);
     if (!pageContext._usesClientRouter) {
-        return { documentHtml, pageContextSerialized: null, pageContext };
+        return { documentHtml, content: null, pageContextSerialized: null, pageContext };
     }
     else {
-        const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
-        return { documentHtml, pageContextSerialized, pageContext };
+        const pageContextSerialized = getPageContextJsonFile(pageContext, streamedValuesLines);
+        return { documentHtml, content: null, pageContextSerialized, pageContext };
     }
 }

package/dist/server/runtime/renderPageServer/streamedValues/asyncIterable.d.ts

@@ -0,0 +1,4 @@
+export { asyncIterable };
+import type { StreamedValueType } from './registry.js';
+import '../../../assertEnvServer.js';
+declare const asyncIterable: StreamedValueType<AsyncIterable<unknown>, IteratorResult<unknown>>;

package/dist/server/runtime/renderPageServer/streamedValues/asyncIterable.js

@@ -0,0 +1,12 @@
+export { asyncIterable };
+import { markers } from '../../../../shared-server-client/streamedValues.js';
+import { chunkToLine } from './lines.js';
+import '../../../assertEnvServer.js';
+const asyncIterable = {
+    marker: markers.asyncIterable,
+    is: (value) => typeof value === 'object' && value !== null && Symbol.asyncIterator in value,
+    read(value) {
+        const iterator = value[Symbol.asyncIterator]();
+        return { next: () => iterator.next(), toLine: chunkToLine, cancel: () => iterator.return?.() };
+    },
+};

package/dist/server/runtime/renderPageServer/streamedValues/lines.d.ts

@@ -0,0 +1,10 @@
+export { serializeLine };
+export { chunkToLine };
+import { type Replacer } from '@brillout/json-serializer/stringify';
+import type { Line, LineContent } from '../../../../shared-server-client/streamedValues.js';
+import '../../../assertEnvServer.js';
+declare function serializeLine(line: Line, replacer: Replacer): string;
+declare function chunkToLine(result: IteratorResult<unknown>): {
+    line: LineContent;
+    isLast: boolean;
+};

package/dist/server/runtime/renderPageServer/streamedValues/lines.js

@@ -0,0 +1,49 @@
+// The encoding of the lines (see shared-server-client/streamedValues.ts)
+export { serializeLine };
+export { chunkToLine };
+import { stringify } from '@brillout/json-serializer/stringify';
+import { assert } from '../../../../utils/assert.js';
+import '../../../assertEnvServer.js';
+// `replacer` replaces the streamed values that a `v` line's value contains
+function serializeLine(line, replacer) {
+    const lineStr = 'v' in line
+        ? `{"s":${line.s},"v":${stringify(line.v, {
+            forbidReactElements: true,
+            valueName: 'a streamed pageContext value',
+            replacer,
+            htmlScriptSafe: { escapeScripts: true, escapeURLs: false },
+        })}}`
+        : JSON.stringify(line);
+    // JSON.stringify() escapes line breaks: one line per JSON value
+    assert(!lineStr.includes('\n'));
+    return lineStr;
+}
+// A ReadableStream / async iterable: one line per chunk, then an `end` line
+function chunkToLine(result) {
+    if (result.done)
+        return { line: { end: true }, isLast: true };
+    return { line: encodeChunk(result.value), isLast: false };
+}
+function encodeChunk(chunk) {
+    if (!(chunk instanceof Uint8Array))
+        return { v: chunk };
+    const text = decodeUtf8(chunk);
+    return text !== null ? { t: text } : { b: encodeBase64url(chunk) };
+}
+const utf8Decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+function decodeUtf8(bytes) {
+    try {
+        return utf8Decoder.decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+function encodeBase64url(bytes) {
+    let binary = '';
+    // In slices: spreading a large array into a single call overflows the stack
+    for (let i = 0; i < bytes.length; i += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    }
+    return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+}

package/dist/server/runtime/renderPageServer/streamedValues/promise.d.ts

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

package/dist/server/runtime/renderPageServer/streamedValues/promise.js

@@ -0,0 +1,14 @@
+export { promise };
+import { markers } from '../../../../shared-server-client/streamedValues.js';
+import { isPromise } from '../../../../utils/isPromise.js';
+import '../../../assertEnvServer.js';
+// One `v` line
+const promise = {
+    marker: markers.promise,
+    is: isPromise,
+    read: (value) => ({
+        next: () => value,
+        toLine: (v) => ({ line: { v }, isLast: true }),
+        cancel: () => { },
+    }),
+};

package/dist/server/runtime/renderPageServer/streamedValues/pump.d.ts

@@ -0,0 +1,10 @@
+export { pumpStreamedValues };
+import { type PageContext_logRuntime } from '../../loggerRuntime.js';
+import { type StreamedValue } from './registry.js';
+import '../../../assertEnvServer.js';
+declare function pumpStreamedValues(pageContext: NonNullable<PageContext_logRuntime>, streamedValues: StreamedValue[], write: (line: string) => void, { failFast }: {
+    failFast: boolean;
+}): {
+    done: Promise<void>;
+    cancel: () => void;
+};

package/dist/server/runtime/renderPageServer/streamedValues/pump.js

@@ -0,0 +1,67 @@
+// Reads the streamed values of a response concurrently and writes their lines.
+// - `failFast: false` (responses): a value that fails is logged and sent as an `error` line.
+// - `failFast: true` (pre-rendering): a value that fails rejects `done`.
+export { pumpStreamedValues };
+import { logRuntimeError } from '../../loggerRuntime.js';
+import { getReplacer } from './registry.js';
+import { serializeLine } from './lines.js';
+import { genPromise } from '../../../../utils/genPromise.js';
+import '../../../assertEnvServer.js';
+function pumpStreamedValues(pageContext, streamedValues, write, { failFast }) {
+    // Stop the values being read: when the response ends early, or when the value fails
+    const cancels = new Set();
+    let pending = 0;
+    let isEnded = false;
+    const { promise: done, resolve, reject } = genPromise({ timeout: null });
+    const end = (settle) => {
+        if (isEnded)
+            return;
+        isEnded = true;
+        cancels.forEach((cancel) => cancel());
+        settle();
+    };
+    const start = (streamedValue) => {
+        pending++;
+        send(streamedValue).then(() => {
+            if (--pending === 0)
+                end(resolve);
+        }, (err) => end(() => reject(err)));
+    };
+    // A line's value can contain new streamed values: they're started after the line is written
+    const writeLine = (line) => {
+        const { replacer, streamedValues } = getReplacer(pageContext);
+        write(serializeLine(line, replacer));
+        streamedValues.forEach(start);
+    };
+    const send = async ({ id: s, type, value }) => {
+        let cancel = () => { };
+        try {
+            const reader = type.read(value);
+            cancel = () => void Promise.resolve(reader.cancel()).catch(() => { });
+            cancels.add(cancel);
+            while (true) {
+                const result = await reader.next();
+                if (isEnded)
+                    return;
+                const { line, isLast } = reader.toLine(result);
+                writeLine({ s, ...line });
+                if (isLast)
+                    return;
+            }
+        }
+        catch (err) {
+            if (isEnded)
+                return;
+            cancel();
+            if (failFast)
+                throw err;
+            logRuntimeError(err, pageContext);
+            writeLine({ s, error: true });
+        }
+        finally {
+            cancels.delete(cancel);
+        }
+    };
+    streamedValues.forEach(start);
+    return { done, cancel: () => end(resolve) };
+}

package/dist/server/runtime/renderPageServer/streamedValues/readableStream.d.ts

@@ -0,0 +1,4 @@
+export { readableStream };
+import type { StreamedValueType } from './registry.js';
+import '../../../assertEnvServer.js';
+declare const readableStream: StreamedValueType<ReadableStream<unknown>, ReadableStreamReadResult<unknown>>;

package/dist/server/runtime/renderPageServer/streamedValues/readableStream.js

@@ -0,0 +1,12 @@
+export { readableStream };
+import { markers } from '../../../../shared-server-client/streamedValues.js';
+import { chunkToLine } from './lines.js';
+import '../../../assertEnvServer.js';
+const readableStream = {
+    marker: markers.readableStream,
+    is: (value) => value instanceof ReadableStream,
+    read(value) {
+        const reader = value.getReader();
+        return { next: () => reader.read(), toLine: chunkToLine, cancel: () => reader.cancel() };
+    },
+};