@bleedingdev/modern-js-runtime-extensions 3.8.3-ultramodern.2

package/dist/esm/rscHtmlStream.mjs

@@ -0,0 +1,86 @@
+const encoder = new TextEncoder();
+const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
+const closingTagsPrefixPattern = /(?:<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?|<\/b(?:o(?:d(?:y>?)?)?)?|<\/?|<[^>]*)$/i;
+const RSC_HTML_CLOSING_TAIL_LIMIT = 8192;
+function injectRSCPayload(rscStream, { injectClosingTags = true } = {}) {
+    const decoder = new TextDecoder();
+    let retainedTail = '';
+    let committedClosingBody = false;
+    let committedHtmlClose = false;
+    let committedProbe = '';
+    let flightPromise;
+    const startFlight = (controller)=>{
+        if (!flightPromise) {
+            flightPromise = writeRSCStream(rscStream, controller);
+            flightPromise.catch((error)=>controller.error(error));
+        }
+        return flightPromise;
+    };
+    const enqueueHtml = (value, controller)=>{
+        if (value) controller.enqueue(encoder.encode(value));
+    };
+    const processHtml = async (value, controller)=>{
+        if (!value) return;
+        if (committedClosingBody) {
+            const probe = committedProbe + value;
+            committedHtmlClose ||= /<\/html>/i.test(probe);
+            committedProbe = probe.slice(-6);
+            enqueueHtml(value, controller);
+            return;
+        }
+        const html = retainedTail + value;
+        retainedTail = '';
+        const suffix = html.match(closingTagsPrefixPattern)?.[0] ?? '';
+        const prefix = suffix ? html.slice(0, -suffix.length) : html;
+        enqueueHtml(prefix, controller);
+        if (!suffix) return void startFlight(controller);
+        if (suffix.length <= RSC_HTML_CLOSING_TAIL_LIMIT) {
+            retainedTail = suffix;
+            return;
+        }
+        await startFlight(controller);
+        if (/<\/body>/i.test(suffix)) {
+            committedClosingBody = true;
+            committedHtmlClose = /<\/html>/i.test(suffix);
+            committedProbe = suffix.slice(-6);
+        }
+        enqueueHtml(suffix, controller);
+    };
+    return new TransformStream({
+        async transform (chunk, controller) {
+            await processHtml(decoder.decode(chunk, {
+                stream: true
+            }), controller);
+        },
+        async flush (controller) {
+            await processHtml(decoder.decode(), controller);
+            await startFlight(controller);
+            const retainedClosingTags = closingTagsPattern.test(retainedTail);
+            enqueueHtml(retainedTail, controller);
+            if (!injectClosingTags) return;
+            if (committedClosingBody) {
+                if (!committedHtmlClose) enqueueHtml('</html>', controller);
+            } else if (!retainedClosingTags) enqueueHtml('</body></html>', controller);
+        }
+    });
+}
+async function writeRSCStream(rscStream, controller) {
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    for await (const chunk of rscStream)try {
+        writeChunk(JSON.stringify(decoder.decode(chunk, {
+            stream: true
+        })), controller);
+    } catch  {
+        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
+        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
+    }
+    const remaining = decoder.decode();
+    if (remaining) writeChunk(JSON.stringify(remaining), controller);
+}
+function writeChunk(chunk, controller) {
+    const script = `(self.__FLIGHT_DATA||=[]).push(${chunk})`;
+    controller.enqueue(encoder.encode(`<script>${script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1')}</script>`));
+}
+export { RSC_HTML_CLOSING_TAIL_LIMIT, injectRSCPayload };

package/dist/esm/safeFailure.mjs

@@ -0,0 +1,78 @@
+const SAFE_FAILURE_MESSAGES = {
+    500: 'Internal Server Error',
+    503: 'Service Unavailable'
+};
+const SAFE_FAILURE_CODES = {
+    500: 'INTERNAL_SERVER_ERROR',
+    503: 'SERVICE_UNAVAILABLE'
+};
+const readErrorProperty = (error, key)=>{
+    if ('object' != typeof error || null === error) return;
+    try {
+        return error[key];
+    } catch  {
+        return;
+    }
+};
+const normalizeFailureStatus = (value)=>'number' == typeof value && Number.isInteger(value) && value >= 400 && value <= 599 ? value : void 0;
+const normalizeDelaySeconds = (value)=>{
+    if ('number' == typeof value) {
+        const seconds = Math.ceil(value);
+        return Number.isFinite(value) && value >= 0 && Number.isSafeInteger(seconds) ? String(seconds) : void 0;
+    }
+    if ('string' == typeof value) {
+        const trimmed = value.trim();
+        if (!/^\d+$/u.test(trimmed)) return;
+        const seconds = Number(trimmed);
+        return Number.isSafeInteger(seconds) ? String(seconds) : void 0;
+    }
+};
+const normalizeHttpDate = (value)=>{
+    try {
+        if (value instanceof Date) {
+            const timestamp = Date.prototype.getTime.call(value);
+            return Number.isFinite(timestamp) ? new Date(timestamp).toUTCString() : void 0;
+        }
+        if ('string' == typeof value) {
+            const trimmed = value.trim();
+            const timestamp = Date.parse(trimmed);
+            if (Number.isFinite(timestamp)) {
+                const canonical = new Date(timestamp).toUTCString();
+                return canonical === trimmed ? canonical : void 0;
+            }
+        }
+    } catch  {}
+};
+const normalizeRetryAfter = (value)=>normalizeDelaySeconds(value) ?? normalizeHttpDate(value);
+const getSafeFailureStatus = (error)=>normalizeFailureStatus(readErrorProperty(error, 'status')) ?? normalizeFailureStatus(readErrorProperty(error, 'statusCode')) ?? 500;
+const createSafeFailureHttpResult = (error)=>{
+    const status = getSafeFailureStatus(error);
+    const retryAfterMs = readErrorProperty(error, 'retryAfterMs');
+    const retryAfter = 503 === status ? normalizeRetryAfter(readErrorProperty(error, 'retryAfter')) ?? normalizeRetryAfter(readErrorProperty(error, 'retryAfterSeconds')) ?? normalizeRetryAfter('number' == typeof retryAfterMs ? retryAfterMs / 1000 : void 0) : void 0;
+    return {
+        status,
+        body: {
+            success: false,
+            error: {
+                code: SAFE_FAILURE_CODES[status] ?? 'REQUEST_FAILED',
+                message: SAFE_FAILURE_MESSAGES[status] ?? 'Request failed',
+                status
+            }
+        },
+        headers: {
+            'content-type': 'application/json; charset=utf-8',
+            ...void 0 === retryAfter ? {} : {
+                'Retry-After': retryAfter
+            }
+        }
+    };
+};
+const createSafeJsonFailureResponse = (error)=>{
+    const result = createSafeFailureHttpResult(error);
+    return new Response(JSON.stringify(result.body), {
+        status: result.status,
+        headers: result.headers
+    });
+};
+const createSafeFailureResponse = createSafeJsonFailureResponse;
+export { createSafeFailureHttpResult, createSafeFailureResponse, createSafeJsonFailureResponse, getSafeFailureStatus };

package/dist/esm/shellStream.mjs

@@ -0,0 +1,38 @@
+import { abortHeadRender, createHeadChunkProcessor } from "./rendererHead.mjs";
+const MISSING_SHELL_MARKER_ERROR = 'React SSR stream ended before the shell marker';
+const createConservingWebShellStream = (source, context, marker, onMissingMarker)=>{
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const headProcessor = createHeadChunkProcessor(context);
+    let markerCarry = '';
+    let markerFound = false;
+    const observeMarker = (chunk)=>{
+        if (markerFound) return;
+        const candidate = markerCarry + chunk;
+        markerFound = candidate.includes(marker);
+        markerCarry = markerFound ? '' : candidate.slice(-(marker.length - 1));
+    };
+    return source.pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            const decoded = decoder.decode(chunk, {
+                stream: true
+            });
+            observeMarker(decoded);
+            const output = headProcessor.push(decoded);
+            if (output) controller.enqueue(encoder.encode(output));
+        },
+        flush (controller) {
+            const decoded = decoder.decode();
+            observeMarker(decoded);
+            if (!markerFound) {
+                abortHeadRender(context);
+                const error = new Error(MISSING_SHELL_MARKER_ERROR);
+                onMissingMarker?.(error);
+                throw error;
+            }
+            const output = headProcessor.finish(decoded);
+            if (output) controller.enqueue(encoder.encode(output));
+        }
+    }));
+};
+export { createConservingWebShellStream };

package/dist/esm-node/helmetCompat.mjs

@@ -0,0 +1,358 @@
+import "node:module";
+const CONTENT_PROPERTIES = new Set([
+    'innerHTML',
+    'cssText'
+]);
+const HTML_ATTRIBUTE_NAMES = {
+    charSet: 'charset',
+    className: 'class',
+    contentEditable: 'contenteditable',
+    httpEquiv: 'http-equiv',
+    hrefLang: 'hreflang',
+    itemProp: 'itemprop',
+    tabIndex: 'tabindex'
+};
+const REACT_ATTRIBUTE_NAMES = {
+    accesskey: 'accessKey',
+    charset: 'charSet',
+    class: 'className',
+    contenteditable: 'contentEditable',
+    contextmenu: 'contextMenu',
+    'http-equiv': 'httpEquiv',
+    hreflang: 'hrefLang',
+    itemprop: 'itemProp',
+    tabindex: 'tabIndex'
+};
+const SEO_PRIORITY_VALUES = {
+    link: {
+        rel: [
+            'amphtml',
+            'canonical',
+            'alternate'
+        ]
+    },
+    meta: {
+        charset: [
+            ''
+        ],
+        name: [
+            'generator',
+            'robots',
+            "description"
+        ],
+        property: [
+            'og:type',
+            'og:title',
+            'og:url',
+            'og:image',
+            'og:image:alt',
+            "og:description",
+            'twitter:url',
+            'twitter:title',
+            "twitter:description",
+            'twitter:image',
+            'twitter:image:alt',
+            'twitter:card',
+            'twitter:site'
+        ]
+    },
+    script: {
+        type: [
+            'application/ld+json'
+        ]
+    }
+};
+const TAG_PRIMARY_ATTRIBUTES = {
+    link: [
+        'rel',
+        'href'
+    ],
+    meta: [
+        'name',
+        'charset',
+        'http-equiv',
+        'property',
+        'itemprop'
+    ],
+    noscript: [
+        'innerHTML'
+    ],
+    script: [
+        'src',
+        'innerHTML'
+    ],
+    style: [
+        'cssText'
+    ]
+};
+const priorityRecords = new WeakSet();
+const priorityTags = new WeakSet();
+const immediateRecords = new WeakMap();
+const createElementFactory = (react)=>react.createElement;
+const renderHeadMarker = (react, marker)=>marker ? createElementFactory(react)('template', marker) : null;
+const toReactAttributes = (tag)=>{
+    const props = {};
+    for (const [attribute, value] of Object.entries(tag))if (!CONTENT_PROPERTIES.has(attribute)) props[REACT_ATTRIBUTE_NAMES[attribute] ?? attribute] = value;
+    return props;
+};
+const toReactProps = (tag, key)=>{
+    const props = {
+        ...toReactAttributes(tag),
+        key,
+        'data-rh': true
+    };
+    if ('innerHTML' in tag || 'cssText' in tag) props.dangerouslySetInnerHTML = {
+        __html: tag.innerHTML ?? tag.cssText ?? ''
+    };
+    return props;
+};
+const escapeHtml = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+const toHtmlAttributeName = (name)=>HTML_ATTRIBUTE_NAMES[name] ?? name;
+const attributesToString = (tag, includeHelmetAttribute = false)=>{
+    const attributes = includeHelmetAttribute ? [
+        'data-rh="true"'
+    ] : [];
+    for (const [name, value] of Object.entries(tag)){
+        if (CONTENT_PROPERTIES.has(name) || false === value || null == value) continue;
+        const attribute = toHtmlAttributeName(name);
+        attributes.push(true === value ? attribute : `${attribute}="${escapeHtml(value)}"`);
+    }
+    return attributes.join(' ');
+};
+const tagsToString = (tagName, tags)=>tags.map((tag)=>{
+        const attributes = attributesToString(tag, true);
+        if (("script" === tagName || "noscript" === tagName) && 'string' == typeof tag.innerHTML) return `<${tagName} ${attributes}>${tag.innerHTML}</${tagName}>`;
+        if ('style' === tagName && 'string' == typeof tag.cssText) return `<style ${attributes}>${tag.cssText}</style>`;
+        return `<${tagName} ${attributes}>`;
+    }).join('');
+const markPriorityHeadRecord = (record, prioritize)=>{
+    if (prioritize) priorityRecords.add(record);
+};
+const isPriorityHeadTag = (tag)=>priorityTags.has(tag);
+const headTagsToComponents = (react, tagName, tags)=>{
+    const createElement = createElementFactory(react);
+    return tags.filter((tag)=>!priorityTags.has(tag)).map((tag, index)=>createElement(tagName, toReactProps(tag, index)));
+};
+const headTitleToComponent = (react, title, attributes)=>{
+    if (!title) return [];
+    const createElement = createElementFactory(react);
+    return [
+        createElement('title', toReactProps(attributes, title), title)
+    ];
+};
+const normalizedEntries = (tag)=>Object.entries(tag).map(([name, value])=>[
+            toHtmlAttributeName(name).toLowerCase(),
+            String(value).toLowerCase()
+        ]);
+const isSeoPriorityTag = (tagName, tag)=>{
+    const values = SEO_PRIORITY_VALUES[tagName];
+    return normalizedEntries(tag).some(([name, value])=>{
+        const allowed = values[name];
+        return void 0 !== allowed && ('charset' === name || allowed.includes(value));
+    });
+};
+const createPriorityHeadDatum = (react, records, dedupe)=>{
+    if (!records.some((record)=>'object' == typeof record && null !== record && priorityRecords.has(record))) return {
+        toComponent: ()=>[],
+        toString: ()=>''
+    };
+    const groups = [
+        'meta',
+        'link',
+        "script"
+    ].map((tagName)=>({
+            tagName,
+            tags: dedupe(tagName, records).filter((tag)=>isSeoPriorityTag(tagName, tag))
+        }));
+    for (const { tags } of groups)for (const tag of tags)priorityTags.add(tag);
+    const createElement = createElementFactory(react);
+    return {
+        toComponent: ()=>groups.flatMap(({ tagName, tags })=>tags.map((tag, index)=>createElement(tagName, toReactProps(tag, `${tagName}-${index}`)))),
+        toString: ()=>groups.map(({ tagName, tags })=>tagsToString(tagName, tags)).join('')
+    };
+};
+const createDatum = (react, tagName, tags)=>({
+        toComponent: ()=>headTagsToComponents(react, tagName, tags),
+        toString: ()=>tagsToString(tagName, tags.filter((tag)=>!priorityTags.has(tag)))
+    });
+const createAttributeDatum = (attributes)=>({
+        toComponent: ()=>toReactAttributes(attributes),
+        toString: ()=>attributesToString(attributes)
+    });
+const createTitleDatum = (react, title, attributes)=>({
+        toComponent: ()=>headTitleToComponent(react, title, attributes),
+        toString: ()=>{
+            if (!title) return '';
+            const serialized = attributesToString(attributes, true);
+            return `<title ${serialized}>${escapeHtml(title)}</title>`;
+        }
+    });
+const normalizeHelmetTitle = (title)=>{
+    if ('string' == typeof title) return title;
+    if (Array.isArray(title)) return title.map((part)=>String(part)).join('');
+};
+const mergeAttributes = (current, next)=>({
+        ...current,
+        ...next ?? {}
+    });
+const isHeadElement = (value)=>'object' == typeof value && null !== value && 'type' in value && 'props' in value && 'object' == typeof value.props && null !== value.props;
+const collectChildren = (react, children, draft)=>{
+    react.Children.forEach(children, (child)=>{
+        if (!react.isValidElement(child) || !isHeadElement(child)) return;
+        const element = child;
+        if (element.type === react.Fragment) return void collectChildren(react, element.props.children, draft);
+        if ('string' != typeof element.type) return;
+        const { children: nestedChildren, ...props } = element.props;
+        if ('title' === element.type) {
+            draft.title = react.Children.toArray(nestedChildren).join('');
+            draft.titleAttributes = mergeAttributes(draft.titleAttributes, props);
+            return;
+        }
+        if ('html' === element.type) {
+            draft.htmlAttributes = mergeAttributes(draft.htmlAttributes ?? {}, props);
+            return;
+        }
+        if ('body' === element.type) {
+            draft.bodyAttributes = mergeAttributes(draft.bodyAttributes ?? {}, props);
+            return;
+        }
+        if ('base' === element.type || 'link' === element.type || 'meta' === element.type || "noscript" === element.type || "script" === element.type || 'style' === element.type) {
+            const tag = {
+                ...props
+            };
+            if (("script" === element.type || 'style' === element.type || "noscript" === element.type) && 'string' == typeof nestedChildren) tag['style' === element.type ? 'cssText' : 'innerHTML'] = nestedChildren;
+            draft[element.type].push(tag);
+        }
+    });
+};
+const createHelmetRecord = (reactValue, props)=>{
+    const draft = {
+        base: void 0 === props.base ? [] : [
+            {
+                ...props.base
+            }
+        ],
+        bodyAttributes: void 0 === props.bodyAttributes ? void 0 : {
+            ...props.bodyAttributes
+        },
+        htmlAttributes: void 0 === props.htmlAttributes ? void 0 : {
+            ...props.htmlAttributes
+        },
+        link: (props.link ?? []).map((tag)=>({
+                ...tag
+            })),
+        meta: (props.meta ?? []).map((tag)=>({
+                ...tag
+            })),
+        noscript: (props.noscript ?? []).map((tag)=>({
+                ...tag
+            })),
+        script: (props.script ?? []).map((tag)=>({
+                ...tag
+            })),
+        style: (props.style ?? []).map((tag)=>({
+                ...tag
+            })),
+        title: normalizeHelmetTitle(props.title),
+        titleAttributes: {
+            ...props.titleAttributes ?? {}
+        }
+    };
+    collectChildren(reactValue, props.children, draft);
+    const record = {
+        ...draft,
+        defaultTitle: props.defaultTitle,
+        prioritizeSeoTags: true === props.prioritizeSeoTags,
+        titleTemplate: props.titleTemplate
+    };
+    markPriorityHeadRecord(record, record.prioritizeSeoTags);
+    return record;
+};
+const getInnermostDefined = (records, pick)=>{
+    for(let index = records.length - 1; index >= 0; index -= 1){
+        const value = pick(records[index]);
+        if (void 0 !== value) return value;
+    }
+};
+const deriveTitle = (records)=>{
+    const title = getInnermostDefined(records, (record)=>record.title);
+    const template = getInnermostDefined(records, (record)=>record.titleTemplate);
+    if (template && title) return template.replaceAll('%s', title);
+    return title || getInnermostDefined(records, (record)=>record.defaultTitle);
+};
+const mergeRecordAttributes = (records, pick)=>records.reduce((merged, record)=>mergeAttributes(merged, pick(record)), {});
+const deriveBaseTags = (records)=>{
+    for(let recordIndex = records.length - 1; recordIndex >= 0; recordIndex--){
+        const tags = records[recordIndex].base;
+        for(let tagIndex = tags.length - 1; tagIndex >= 0; tagIndex--)if (tags[tagIndex].href) return [
+            tags[tagIndex]
+        ];
+    }
+    return [];
+};
+const getPrimaryAttribute = (tagName, tag)=>{
+    const candidates = TAG_PRIMARY_ATTRIBUTES[tagName];
+    let selectedKey;
+    let selectedValue;
+    for (const [key, value] of Object.entries(tag)){
+        const normalizedKey = CONTENT_PROPERTIES.has(key) ? key : toHtmlAttributeName(key).toLowerCase();
+        if (candidates.includes(normalizedKey)) {
+            if ('rel' !== selectedKey || 'canonical' !== String(selectedValue).toLowerCase()) {
+                if ('rel' !== normalizedKey || 'stylesheet' !== String(value).toLowerCase()) {
+                    selectedKey = normalizedKey;
+                    selectedValue = value;
+                }
+            }
+        }
+    }
+    if (void 0 === selectedKey || !selectedValue) return;
+    return {
+        key: selectedKey,
+        value: String(selectedValue).toLowerCase()
+    };
+};
+const dedupeTags = (tagName, records)=>{
+    const approvedValues = new Map();
+    const approved = [];
+    for(let index = records.length - 1; index >= 0; index -= 1){
+        const instanceValues = new Map();
+        const kept = [];
+        for (const tag of records[index][tagName]){
+            const primary = getPrimaryAttribute(tagName, tag);
+            if (void 0 === primary || approvedValues.get(primary.key)?.has(primary.value)) continue;
+            const seen = instanceValues.get(primary.key) ?? new Set();
+            seen.add(primary.value);
+            instanceValues.set(primary.key, seen);
+            kept.push(tag);
+        }
+        approved.unshift(...kept);
+        for (const [key, values] of instanceValues){
+            const target = approvedValues.get(key);
+            if (void 0 === target) approvedValues.set(key, values);
+            else for (const value of values)target.add(value);
+        }
+    }
+    return approved;
+};
+const deriveHelmetServerState = (react, records)=>{
+    const priority = createPriorityHeadDatum(react, records, dedupeTags);
+    return {
+        base: createDatum(react, 'base', deriveBaseTags(records)),
+        bodyAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.bodyAttributes)),
+        htmlAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.htmlAttributes)),
+        link: createDatum(react, 'link', dedupeTags('link', records)),
+        meta: createDatum(react, 'meta', dedupeTags('meta', records)),
+        noscript: createDatum(react, "noscript", dedupeTags("noscript", records)),
+        priority,
+        script: createDatum(react, "script", dedupeTags("script", records)),
+        style: createDatum(react, 'style', dedupeTags('style', records)),
+        title: createTitleDatum(react, deriveTitle(records), mergeRecordAttributes(records, (record)=>record.titleAttributes))
+    };
+};
+const collectImmediateHelmetState = (react, context, record)=>{
+    const records = immediateRecords.get(context) ?? [];
+    if (!immediateRecords.has(context)) immediateRecords.set(context, records);
+    records.push(record);
+    return deriveHelmetServerState(react, records);
+};
+export { collectImmediateHelmetState, createHelmetRecord, createPriorityHeadDatum, deriveHelmetServerState, headTagsToComponents, headTitleToComponent, isPriorityHeadTag, markPriorityHeadRecord, renderHeadMarker };

package/dist/esm-node/html.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+const SAFE_HTML_ATTRIBUTE_NAME = /^[^\u0000-\u0020"'<>/=]+$/u;
+const isSafeHtmlAttributeName = (name)=>SAFE_HTML_ATTRIBUTE_NAME.test(name);
+const escapeHtmlAttribute = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+export { escapeHtmlAttribute, isSafeHtmlAttributeName };

package/dist/esm-node/index.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+export * from "./html.mjs";
+export * from "./navigationWarmup.mjs";
+export * from "./rendererHead.mjs";
+export * from "./shellStream.mjs";

package/dist/esm-node/navigationWarmup.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+const realmNamespaces = new WeakMap();
+let nextRealmNamespace = 0;
+function getNavigationWarmupCacheKey(runtimeContext, chunkLoader, publicPath, warmupKey) {
+    let loaderNamespaces = realmNamespaces.get(runtimeContext);
+    if (void 0 === loaderNamespaces) {
+        loaderNamespaces = new WeakMap();
+        realmNamespaces.set(runtimeContext, loaderNamespaces);
+    }
+    let publicPathNamespaces = loaderNamespaces.get(chunkLoader);
+    if (void 0 === publicPathNamespaces) {
+        publicPathNamespaces = new Map();
+        loaderNamespaces.set(chunkLoader, publicPathNamespaces);
+    }
+    let namespace = publicPathNamespaces.get(publicPath);
+    if (void 0 === namespace) {
+        namespace = `realm-${++nextRealmNamespace}`;
+        publicPathNamespaces.set(publicPath, namespace);
+    }
+    return `${namespace}:${warmupKey}`;
+}
+export { getNavigationWarmupCacheKey };

package/dist/esm-node/node.mjs

@@ -0,0 +1,62 @@
+import "node:module";
+import { Transform, pipeline } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import { abortHeadRender, createHeadChunkProcessor } from "./rendererHead.mjs";
+export * from "./rendererHead.mjs";
+const toError = (reason)=>reason instanceof Error ? reason : new Error(String(reason));
+const createNodeHeadMarkerStripper = (context, terminalMarker)=>{
+    const decoder = new StringDecoder('utf8');
+    const processor = createHeadChunkProcessor(context);
+    let terminalCarry = '';
+    let sawTerminalMarker = void 0 === terminalMarker;
+    const observeTerminalMarker = (output)=>{
+        if (!sawTerminalMarker && void 0 !== terminalMarker) {
+            const observed = terminalCarry + output;
+            sawTerminalMarker = observed.includes(terminalMarker);
+            terminalCarry = observed.slice(Math.max(0, observed.length - terminalMarker.length + 1));
+        }
+        return output;
+    };
+    return new Transform({
+        transform (chunk, _encoding, callback) {
+            try {
+                callback(null, observeTerminalMarker(processor.push(decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))));
+            } catch (error) {
+                callback(toError(error));
+            }
+        },
+        flush (callback) {
+            try {
+                const output = observeTerminalMarker(processor.finish(decoder.end()));
+                callback(null, sawTerminalMarker ? output : `${output}${terminalMarker}`);
+            } catch (error) {
+                callback(toError(error));
+            }
+        },
+        destroy (error, callback) {
+            try {
+                abortHeadRender(context);
+                callback(error);
+            } catch (abortError) {
+                callback(error ?? toError(abortError));
+            }
+        }
+    });
+};
+const createOnceErrorReporter = (onError)=>{
+    let reported = false;
+    return (error)=>{
+        if (!reported) {
+            reported = true;
+            onError?.(error);
+        }
+    };
+};
+const pipeNodeHeadStream = (options)=>{
+    const { source, destination, context, terminalMarker, onError } = options;
+    const stripper = createNodeHeadMarkerStripper(context, terminalMarker);
+    pipeline(source, stripper, destination, (error)=>{
+        if (null !== error) onError?.(error);
+    });
+};
+export { createNodeHeadMarkerStripper, createOnceErrorReporter, pipeNodeHeadStream };