@jk2908/solas 0.5.4 → 0.6.0

package/dist/internal/prerender.js

@@ -1,368 +1,340 @@
 import path from 'node:path';
 import { compile } from 'path-to-regexp';
-import { BasePath } from '../utils/base-path.js';
+import { applyBasePath } from '../utils/base-path.js';
 import { Logger } from '../utils/logger.js';
-import { Solas } from '../solas.js';
+import * as Config from '../config.js';
+import * as Solas from '../solas.js';
 import { toPathPattern } from './http-router/utils.js';
 import { Runtime as AdapterRuntime } from './runtimes/runtime.js';
 const logger = new Logger();
-export { Prerender };
-var Prerender;
-(function (Prerender) {
-    const DEFAULT_CONCURRENCY = 4;
-    let Artifact;
-    (function (Artifact) {
-        /**
-         * Check whether a file name is safe to join under an artifact directory
-         */
-        function isArtifactFileName(value) {
-            return (typeof value === 'string' &&
-                value.length > 0 &&
-                path.basename(value) === value &&
-                !value.includes(path.sep));
-        }
-        /**
-         * Get the root directory path where prerender artifacts are stored,
-         * based on the output directory specified in the configuration
-         */
-        function getRootPath(outDir) {
-            return path.join(outDir, Solas.Config.GENERATED_DIR, 'ppr');
-        }
-        Artifact.getRootPath = getRootPath;
-        /**
-         * Get the file system path for storing prerender artifacts for a given route
-         */
-        function getPath(outDir, pathname) {
-            const root = path.resolve(getRootPath(outDir));
-            const dir = pathname === '/' ? 'index' : pathname.replace(/^\//, '');
-            const artifactPath = path.resolve(root, dir);
-            // this also runs at request time, so make sure the pathname cannot escape the artifact folder
-            if (artifactPath !== root && !artifactPath.startsWith(`${root}${path.sep}`)) {
-                throw new Error('[prerender] invalid artifact path');
-            }
-            return artifactPath;
-        }
-        Artifact.getPath = getPath;
-        /**
-         * Get the file system path for a single prerender artifact file under a route directory
-         */
-        function getFilePath(outDir, pathname, fileName) {
-            if (!isArtifactFileName(fileName)) {
-                throw new Error('[prerender] invalid artifact file name');
-            }
-            return path.join(getPath(outDir, pathname), fileName);
-        }
-        Artifact.getFilePath = getFilePath;
-        /**
-         * File name used for saved full-prerender html inside each route artifact directory
-         */
-        Artifact.FULL_PRERENDER_FILENAME = 'prerendered.html';
-        /**
-         * Load the postponed state for a given route from the file system, if it exists
-         */
-        async function loadPostponedState(outDir, pathname) {
-            let filePath;
-            try {
-                filePath = path.join(getPath(outDir, pathname), 'postponed.json');
-            }
-            catch (err) {
-                logger.warn(`[prerender:artifacts] rejected postponed state path for ${pathname}`, Logger.print(err));
-                return null;
-            }
-            if (!(await AdapterRuntime.exists(filePath)))
-                return null;
-            try {
-                return JSON.parse(await AdapterRuntime.readText(filePath));
-            }
-            catch {
-                return null;
-            }
-        }
-        Artifact.loadPostponedState = loadPostponedState;
-        /**
-         * Load the prelude HTML for a given route from the file system, if it exists
-         */
-        async function loadPrelude(outDir, pathname) {
-            let filePath;
-            try {
-                filePath = path.join(getPath(outDir, pathname), 'prelude.html');
-            }
-            catch (err) {
-                logger.warn(`[prerender:artifacts] rejected prelude path for ${pathname}`, Logger.print(err));
-                return null;
-            }
-            if (!(await AdapterRuntime.exists(filePath)))
-                return null;
-            try {
-                return await AdapterRuntime.readText(filePath);
-            }
-            catch {
-                return null;
-            }
-        }
-        Artifact.loadPrelude = loadPrelude;
-        /**
-         * Load the prerender artifact metadata for a given route from the file system, if it exists and is valid
-         */
-        async function loadMetadata(outDir, pathname) {
-            let filePath;
-            try {
-                filePath = path.join(getPath(outDir, pathname), 'metadata.json');
-            }
-            catch (err) {
-                logger.warn(`[prerender:artifacts] rejected metadata path for ${pathname}`, Logger.print(err));
-                return null;
-            }
-            if (!(await AdapterRuntime.exists(filePath)))
-                return null;
+const DEFAULT_CONCURRENCY = 4;
+/**
+ * Check whether a file name is safe to join under an artifact directory
+ */
+function isArtifactFileName(value) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        path.basename(value) === value &&
+        !value.includes(path.sep));
+}
+/**
+ * Get the root directory path where prerender artifacts are stored,
+ * based on the output directory specified in the configuration
+ */
+export function getArtifactRootPath(outDir) {
+    return path.join(outDir, Config.GENERATED_DIR, 'ppr');
+}
+/**
+ * Get the file system path for storing prerender artifacts for a given route
+ */
+export function getArtifactPath(outDir, pathname) {
+    const root = path.resolve(getArtifactRootPath(outDir));
+    const dir = pathname === '/' ? 'index' : pathname.replace(/^\//, '');
+    const artifactPath = path.resolve(root, dir);
+    // this also runs at request time, so make sure the pathname cannot escape the artifact folder
+    if (artifactPath !== root && !artifactPath.startsWith(`${root}${path.sep}`)) {
+        throw new Error('[prerender] invalid artifact path');
+    }
+    return artifactPath;
+}
+/**
+ * Get the file system path for a single prerender artifact file under a route directory
+ */
+export function getArtifactFilePath(outDir, pathname, fileName) {
+    if (!isArtifactFileName(fileName)) {
+        throw new Error('[prerender] invalid artifact file name');
+    }
+    return path.join(getArtifactPath(outDir, pathname), fileName);
+}
+/**
+ * File name used for saved full-prerender html inside each route artifact directory
+ */
+export const FULL_PRERENDER_FILENAME = 'prerendered.html';
+/**
+ * Load the postponed state for a given route from the file system, if it exists
+ */
+export async function loadPostponedState(outDir, pathname) {
+    let filePath;
+    try {
+        filePath = path.join(getArtifactPath(outDir, pathname), 'postponed.json');
+    }
+    catch (err) {
+        logger.warn(`[prerender:artifacts] rejected postponed state path for ${pathname}`, Logger.print(err));
+        return null;
+    }
+    if (!(await AdapterRuntime.exists(filePath)))
+        return null;
+    try {
+        return JSON.parse(await AdapterRuntime.readText(filePath));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load the prelude HTML for a given route from the file system, if it exists
+ */
+export async function loadPrelude(outDir, pathname) {
+    let filePath;
+    try {
+        filePath = path.join(getArtifactPath(outDir, pathname), 'prelude.html');
+    }
+    catch (err) {
+        logger.warn(`[prerender:artifacts] rejected prelude path for ${pathname}`, Logger.print(err));
+        return null;
+    }
+    if (!(await AdapterRuntime.exists(filePath)))
+        return null;
+    try {
+        return await AdapterRuntime.readText(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load the prerender artifact metadata for a given route from the file system, if it exists and is valid
+ */
+export async function loadMetadata(outDir, pathname) {
+    let filePath;
+    try {
+        filePath = path.join(getArtifactPath(outDir, pathname), 'metadata.json');
+    }
+    catch (err) {
+        logger.warn(`[prerender:artifacts] rejected metadata path for ${pathname}`, Logger.print(err));
+        return null;
+    }
+    if (!(await AdapterRuntime.exists(filePath)))
+        return null;
+    try {
+        const value = JSON.parse(await AdapterRuntime.readText(filePath));
+        if (!value || typeof value !== 'object')
+            return null;
+        const schema = value.schema;
+        const route = value.route;
+        const createdAt = value.createdAt;
+        const mode = value.mode;
+        if (typeof schema !== 'string')
+            return null;
+        if (typeof route !== 'string')
+            return null;
+        if (typeof createdAt !== 'number')
+            return null;
+        if (mode !== 'full' && mode !== 'ppr')
+            return null;
+        return {
+            schema,
+            route,
+            createdAt,
+            mode,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a prerender artifact is compatible with the current application version and route,
+ * based on its metadata
+ */
+export function isCompatible(artifactMetadata, pathname, mode) {
+    const schema = Solas.getVersion();
+    return (artifactMetadata.schema === schema &&
+        artifactMetadata.route === pathname &&
+        artifactMetadata.mode === mode);
+}
+// shared instances, both are stateless so one per module is fine
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/**
+ * Compose the prelude HTML and the resume stream into a single HTML stream, by injecting the resume stream
+ * into the prelude at the appropriate location (before </body> or </html>)
+ */
+export function composePreludeAndResume(prelude, resumeStream) {
+    // `prelude` is the static shell html as one complete string, usually shaped like
+    // `<html>...<body>static shell...</body></html>` or an html fragment with no close tags
+    // search both cases to avoid duplicating the full string with toLowerCase
+    const bodyClose = Math.max(prelude.lastIndexOf('</body>'), prelude.lastIndexOf('</BODY>'));
+    const htmlClose = Math.max(prelude.lastIndexOf('</html>'), prelude.lastIndexOf('</HTML>'));
+    // prefer inserting before </body>, then before </html>, and fall back
+    // to appending when the prelude is only a fragment with no close tags
+    const splitAt = bodyClose >= 0 ? bodyClose : htmlClose >= 0 ? htmlClose : prelude.length;
+    return new ReadableStream({
+        async start(controller) {
+            // send everything before the closing tags so the resume stream can be injected
+            controller.enqueue(encoder.encode(prelude.slice(0, splitAt)));
+            // resumeStream is the html React emits when it resumes postponed work for this page. Its
+            // first chunk begins with an extra `</body></html>` pair, then continues with the
+            // resumed scripts and markup for the unfinished work. Strip that leading
+            // pair once, then pass the rest through unchanged
+            const reader = resumeStream.getReader();
+            let strippedLeadingClose = false;
             try {
-                const value = JSON.parse(await AdapterRuntime.readText(filePath));
-                if (!value || typeof value !== 'object')
-                    return null;
-                const schema = value.schema;
-                const route = value.route;
-                const createdAt = value.createdAt;
-                const mode = value.mode;
-                if (typeof schema !== 'string')
-                    return null;
-                if (typeof route !== 'string')
-                    return null;
-                if (typeof createdAt !== 'number')
-                    return null;
-                if (mode !== 'full' && mode !== 'ppr')
-                    return null;
-                return {
-                    schema,
-                    route,
-                    createdAt,
-                    mode,
-                };
-            }
-            catch {
-                return null;
-            }
-        }
-        Artifact.loadMetadata = loadMetadata;
-        /**
-         * Check if a prerender artifact is compatible with the current application version and route,
-         * based on its metadata
-         */
-        function isCompatible(artifactMetadata, pathname, mode) {
-            const schema = Solas.getVersion();
-            return (artifactMetadata.schema === schema &&
-                artifactMetadata.route === pathname &&
-                artifactMetadata.mode === mode);
-        }
-        Artifact.isCompatible = isCompatible;
-        // shared instances, both are stateless so one per module is fine
-        const encoder = new TextEncoder();
-        const decoder = new TextDecoder();
-        /**
-         * Compose the prelude HTML and the resume stream into a single HTML stream, by injecting the resume stream
-         * into the prelude at the appropriate location (before </body> or </html>)
-         */
-        function composePreludeAndResume(prelude, resumeStream) {
-            // `prelude` is the static shell html as one complete string, usually shaped like
-            // `<html>...<body>static shell...</body></html>` or an html fragment with no close tags
-            // search both cases to avoid duplicating the full string with toLowerCase
-            const bodyClose = Math.max(prelude.lastIndexOf('</body>'), prelude.lastIndexOf('</BODY>'));
-            const htmlClose = Math.max(prelude.lastIndexOf('</html>'), prelude.lastIndexOf('</HTML>'));
-            // prefer inserting before </body>, then before </html>, and fall back
-            // to appending when the prelude is only a fragment with no close tags
-            const splitAt = bodyClose >= 0 ? bodyClose : htmlClose >= 0 ? htmlClose : prelude.length;
-            return new ReadableStream({
-                async start(controller) {
-                    // send everything before the closing tags so the resume stream can be injected
-                    controller.enqueue(encoder.encode(prelude.slice(0, splitAt)));
-                    // resumeStream is the html React emits when it resumes postponed work for this page. Its
-                    // first chunk begins with an extra `</body></html>` pair, then continues with the
-                    // resumed scripts and markup for the unfinished work. Strip that leading
-                    // pair once, then pass the rest through unchanged
-                    const reader = resumeStream.getReader();
-                    let strippedLeadingClose = false;
-                    try {
-                        while (true) {
-                            const { value, done } = await reader.read();
-                            if (done)
-                                break;
-                            if (!value)
-                                continue;
-                            if (!strippedLeadingClose) {
-                                strippedLeadingClose = true;
-                                const text = decoder.decode(value);
-                                // we already wrote the prelude up to the insertion point before its closing tags.
-                                // React's first resumed chunk starts with an extra `</body></html>` pair,
-                                // so strip that prefix and keep the rest of the chunk
-                                const trimmed = text.replace(/^\s*<\/body>\s*<\/html>/i, '');
-                                if (trimmed.length > 0)
-                                    controller.enqueue(encoder.encode(trimmed));
-                                continue;
-                            }
-                            // once the duplicated `</body></html>` prefix is removed, stop trying to
-                            // interpret the stream and forward each remaining chunk exactly as React
-                            // emitted it
-                            controller.enqueue(value);
-                        }
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    if (!value)
+                        continue;
+                    if (!strippedLeadingClose) {
+                        strippedLeadingClose = true;
+                        const text = decoder.decode(value);
+                        // we already wrote the prelude up to the insertion point before its closing tags.
+                        // React's first resumed chunk starts with an extra `</body></html>` pair,
+                        // so strip that prefix and keep the rest of the chunk
+                        const trimmed = text.replace(/^\s*<\/body>\s*<\/html>/i, '');
+                        if (trimmed.length > 0)
+                            controller.enqueue(encoder.encode(trimmed));
+                        continue;
                     }
-                    finally {
-                        reader.releaseLock();
-                        controller.close();
-                    }
-                },
-            });
-        }
-        Artifact.composePreludeAndResume = composePreludeAndResume;
-    })(Artifact = Prerender.Artifact || (Prerender.Artifact = {}));
-    let Runtime;
-    (function (Runtime) {
-        /**
-         * Custom error class to indicate that prerendering has been postponed to request-time
-         */
-        class Postponed extends Error {
-            constructor(message = 'postponed') {
-                super(message);
-                this.name = 'Postponed';
+                    // once the duplicated `</body></html>` prefix is removed, stop trying to
+                    // interpret the stream and forward each remaining chunk exactly as React
+                    // emitted it
+                    controller.enqueue(value);
+                }
             }
-        }
-        Runtime.Postponed = Postponed;
-        /**
-         * Type guard to check if an error is a Postponed error, including wrapped errors like
-         * AbortError or TimeoutError
-         */
-        function isPostponed(error) {
-            if (error instanceof Postponed)
-                return true;
-            if (error instanceof Error &&
-                (error.name === 'AbortError' || error.name === 'TimeoutError')) {
-                if (error.cause instanceof Postponed)
-                    return true;
+            finally {
+                reader.releaseLock();
+                controller.close();
             }
-            return false;
+        },
+    });
+}
+/**
+ * Custom error class to indicate that prerendering has been postponed to request-time
+ */
+export class Postponed extends Error {
+    constructor(message = 'postponed') {
+        super(message);
+        this.name = 'Postponed';
+    }
+}
+/**
+ * Type guard to check if an error is a Postponed error, including wrapped errors like
+ * AbortError or TimeoutError
+ */
+export function isPostponed(error) {
+    if (error instanceof Postponed)
+        return true;
+    if (error instanceof Error &&
+        (error.name === 'AbortError' || error.name === 'TimeoutError')) {
+        if (error.cause instanceof Postponed)
+            return true;
+    }
+    return false;
+}
+/**
+ * Get the prerender concurrency value from the environment variable, or return the default
+ * if it's not set or invalid
+ */
+export function getConcurrency() {
+    const v = Number(process.env.SOLAS_PRERENDER_CONCURRENCY);
+    if (!Number.isInteger(v) || v <= 0) {
+        return DEFAULT_CONCURRENCY;
+    }
+    return v;
+}
+/**
+ * Extract the prerendering mode ('full', 'ppr', or false) from the source code of a route module, by
+ * looking for an exported `prerender` binding and validating its value
+ */
+export async function getStaticFlag(filePath, buildContext) {
+    return buildContext.exportReader.literal(filePath, 'prerender', (v) => v === 'full' || v === 'ppr' || v === false);
+}
+/**
+ * Get the list of static parameters for a dynamic route, by looking for an exported `params` function
+ * in the route module and calling it to get the list of parameter objects
+ */
+export async function getStaticParams(filePath, buildContext) {
+    const params = await buildContext.exportReader.value(filePath, 'params', (v) => typeof v === 'function');
+    if (!params)
+        return [];
+    const resolved = await Promise.resolve().then(() => params());
+    if (!Array.isArray(resolved))
+        return [];
+    return resolved;
+}
+/**
+ * Generate the list of prerenderable routes for a dynamic route, by combining the static parameters obtained from
+ * the route module with the route pattern, and filtering out any routes that still contain dynamic segments
+ */
+export function getDynamicRouteList(route, paramNames, staticParams) {
+    if (!staticParams.length)
+        return [];
+    const { path: compilePath, wildcardNames } = toPathPattern(route, paramNames);
+    const toPath = compile(compilePath);
+    return staticParams
+        .map(value => {
+        try {
+            return toPath(Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+                key,
+                wildcardNames.has(key)
+                    ? Array.isArray(entry)
+                        ? entry.map(part => String(part))
+                        : [String(entry)]
+                    : Array.isArray(entry)
+                        ? entry.map(part => String(part)).join('/')
+                        : String(entry),
+            ])));
         }
-        Runtime.isPostponed = isPostponed;
-    })(Runtime = Prerender.Runtime || (Prerender.Runtime = {}));
-    let Build;
-    (function (Build) {
-        /**
-         * Get the prerender concurrency value from the environment variable, or return the default
-         * if it's not set or invalid
-         */
-        function getConcurrency() {
-            const v = Number(process.env.SOLAS_PRERENDER_CONCURRENCY);
-            if (!Number.isInteger(v) || v <= 0) {
-                return DEFAULT_CONCURRENCY;
-            }
-            return v;
+        catch {
+            return null;
         }
-        Build.getConcurrency = getConcurrency;
-        /**
-         * Extract the prerendering mode ('full', 'ppr', or false) from the source code of a route module, by
-         * looking for an exported `prerender` binding and validating its value
-         */
-        async function getStaticFlag(filePath, buildContext) {
-            return buildContext.exportReader.literal(filePath, 'prerender', (v) => v === 'full' || v === 'ppr' || v === false);
-        }
-        Build.getStaticFlag = getStaticFlag;
-        /**
-         * Get the list of static parameters for a dynamic route, by looking for an exported `params` function
-         * in the route module and calling it to get the list of parameter objects
-         */
-        async function getStaticParams(filePath, buildContext) {
-            const params = await buildContext.exportReader.value(filePath, 'params', (v) => typeof v === 'function');
-            if (!params)
-                return [];
-            const resolved = await Promise.resolve().then(() => params());
-            if (!Array.isArray(resolved))
-                return [];
-            return resolved;
-        }
-        Build.getStaticParams = getStaticParams;
-        /**
-         * Generate the list of prerenderable routes for a dynamic route, by combining the static parameters obtained from
-         * the route module with the route pattern, and filtering out any routes that still contain dynamic segments
-         */
-        function getDynamicRouteList(route, paramNames, staticParams) {
-            if (!staticParams.length)
-                return [];
-            const { path: compilePath, wildcardNames } = toPathPattern(route, paramNames);
-            const toPath = compile(compilePath);
-            return staticParams
-                .map(value => {
-                try {
-                    return toPath(Object.fromEntries(Object.entries(value).map(([key, entry]) => [
-                        key,
-                        wildcardNames.has(key)
-                            ? Array.isArray(entry)
-                                ? entry.map(part => String(part))
-                                : [String(entry)]
-                            : Array.isArray(entry)
-                                ? entry.map(part => String(part)).join('/')
-                                : String(entry),
-                    ])));
-                }
-                catch {
-                    return null;
-                }
+    })
+        .filter((value) => value !== null)
+        .filter(r => !r.includes(':') && !r.includes('*'));
+}
+/**
+ * Function to prerender a single route by making a request to the route with special headers, and returning the
+ * result which includes either the prerender artifact or an error/status code if the prerendering failed or was
+ * postponed to request-time
+ */
+export async function get(app, route, opts) {
+    const url = `${opts.origin ?? `http://${Config.SLUG}.local`}${applyBasePath(route, opts.base)}`;
+    const res = await app.fetch(new Request(url, {
+        headers: {
+            Accept: 'text/html',
+            [`x-${Config.SLUG}-prerender`]: '1',
+            [`x-${Config.SLUG}-prerender-artifact`]: '1',
+        },
+    }));
+    if (!(res instanceof Response)) {
+        const error = new TypeError(`Invalid response for ${route}`);
+        logger.error(`[prerender:get] ${error.message}`, error);
+        throw error;
+    }
+    if (!res.ok)
+        return { route, status: res.status };
+    return { route, artifact: await res.json() };
+}
+/**
+ * Run the prerendering process for a list of routes with a specified concurrency limit,
+ * by calling the 'get' function for each route and yielding the results as they become available
+ */
+export async function* run(app, routes, opts) {
+    const limit = Math.max(1, Math.min(opts.concurrency ?? 4, routes.length || 1));
+    let index = 0;
+    const pending = new Map();
+    function enqueue() {
+        while (index < routes.length && pending.size < limit) {
+            const i = index++;
+            const value = routes[i];
+            pending.set(i, get(app, value, {
+                base: opts.base,
+                origin: opts.origin,
             })
-                .filter((value) => value !== null)
-                .filter(r => !r.includes(':') && !r.includes('*'));
-        }
-        Build.getDynamicRouteList = getDynamicRouteList;
-        /**
-         * Function to prerender a single route by making a request to the route with special headers, and returning the
-         * result which includes either the prerender artifact or an error/status code if the prerendering failed or was
-         * postponed to request-time
-         */
-        async function get(app, route, opts) {
-            const url = `${opts.origin ?? `http://${Solas.Config.SLUG}.local`}${BasePath.apply(route, opts.base)}`;
-            const res = await app.fetch(new Request(url, {
-                headers: {
-                    Accept: 'text/html',
-                    [`x-${Solas.Config.SLUG}-prerender`]: '1',
-                    [`x-${Solas.Config.SLUG}-prerender-artifact`]: '1',
-                },
-            }));
-            if (!(res instanceof Response)) {
-                const error = new TypeError(`Invalid response for ${route}`);
-                logger.error(`[prerender:get] ${error.message}`, error);
-                throw error;
-            }
-            if (!res.ok)
-                return { route, status: res.status };
-            return { route, artifact: await res.json() };
-        }
-        Build.get = get;
-        /**
-         * Run the prerendering process for a list of routes with a specified concurrency limit,
-         * by calling the 'get' function for each route and yielding the results as they become available
-         */
-        async function* run(app, routes, opts) {
-            const limit = Math.max(1, Math.min(opts.concurrency ?? 4, routes.length || 1));
-            let index = 0;
-            const pending = new Map();
-            function enqueue() {
-                while (index < routes.length && pending.size < limit) {
-                    const i = index++;
-                    const value = routes[i];
-                    pending.set(i, get(app, value, {
-                        base: opts.base,
-                        origin: opts.origin,
-                    })
-                        .then(result => ({ index: i, result }))
-                        .catch(err => ({
-                        index: i,
-                        result: { route: value, error: err },
-                    })));
-                }
-            }
-            enqueue();
-            while (pending.size > 0) {
-                const settled = await Promise.race(pending.values());
-                pending.delete(settled.index);
-                yield settled.result;
-                enqueue();
-            }
+                .then(result => ({ index: i, result }))
+                .catch(err => ({
+                index: i,
+                result: { route: value, error: err },
+            })));
         }
-        Build.run = run;
-    })(Build = Prerender.Build || (Prerender.Build = {}));
-})(Prerender || (Prerender = {}));
+    }
+    enqueue();
+    while (pending.size > 0) {
+        const settled = await Promise.race(pending.values());
+        pending.delete(settled.index);
+        yield settled.result;
+        enqueue();
+    }
+}