@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.4 → 3.9.0-ultramodern.6

package/dist/esm/routerProvider.mjs

@@ -0,0 +1,58 @@
+import { merge } from "@modern-js/runtime-utils/merge";
+function reportUnsupportedProviderRegistryHooks(providerPlugin, routerProviderRegistryHooks) {
+    const unsupportedHookNames = Object.keys(providerPlugin.registryHooks ?? {}).filter((hookName)=>!(hookName in routerProviderRegistryHooks));
+    if (unsupportedHookNames.length > 0) console.warn(`[@modern-js/runtime] The router provider "${providerPlugin.name}" declares registry hooks outside the router hook contract: ${unsupportedHookNames.join(', ')}. These hooks are not registered when the provider is resolved through \`runtime.router.framework\` — declare them on a separate runtime plugin instead.`);
+    return unsupportedHookNames;
+}
+function createRouterProviderRealm(registrations) {
+    const providers = new Map();
+    let defaultProvider;
+    for (const registration of registrations){
+        if (0 === registration.name.length) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
+        if (providers.has(registration.name)) throw new Error(`[@modern-js/runtime] Router provider "${registration.name}" is declared more than once in the same runtime realm.`);
+        if (true === registration.isDefault && void 0 !== defaultProvider && defaultProvider !== registration.name) throw new Error(`[@modern-js/runtime] Router provider realm declares both "${defaultProvider}" and "${registration.name}" as defaults.`);
+        providers.set(registration.name, registration.factory);
+        if (true === registration.isDefault) defaultProvider = registration.name;
+    }
+    const providerNames = Object.freeze([
+        ...providers.keys()
+    ]);
+    return Object.freeze({
+        ...void 0 !== defaultProvider ? {
+            defaultProvider
+        } : {},
+        get: (name)=>providers.get(name),
+        names: ()=>providerNames
+    });
+}
+function resolveRouterProvider(framework, options) {
+    const name = framework || options.realm.defaultProvider;
+    const realmProviderNames = options.realm.names();
+    if (void 0 === name) throw new Error(`[@modern-js/runtime] The app-owned router provider realm does not declare a default provider. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}.`);
+    const factory = options.realm.get(name);
+    if (void 0 === factory) throw new Error(`[@modern-js/runtime] Router provider "${name}" is not registered in the app-owned router provider realm. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}.`);
+    return factory;
+}
+function createRouterPlugin({ defaultProvider, registryHooks, localProviders = [] }) {
+    const realm = createRouterProviderRealm([
+        {
+            ...defaultProvider,
+            isDefault: true
+        },
+        ...localProviders
+    ]);
+    return (userConfig = {})=>({
+            name: '@modern-js/plugin-router',
+            registryHooks,
+            setup (api) {
+                const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
+                const factory = resolveRouterProvider(mergedConfig.framework, {
+                    realm
+                });
+                const provider = factory(userConfig);
+                reportUnsupportedProviderRegistryHooks(provider, registryHooks);
+                provider.setup?.(api);
+            }
+        });
+}
+export { createRouterPlugin, createRouterProviderRealm, reportUnsupportedProviderRegistryHooks, resolveRouterProvider };

package/dist/esm/routerState.mjs

@@ -0,0 +1,105 @@
+import { createRuntimeContextExtension } from "./contextExtensions.mjs";
+const routerRuntimeStateExtension = createRuntimeContextExtension('@modern-js/runtime:router-runtime-state');
+const routerServerSnapshotExtension = createRuntimeContextExtension('@modern-js/runtime:router-server-snapshot');
+function getRouterRuntimeState(runtimeContext) {
+    return routerRuntimeStateExtension.get(runtimeContext);
+}
+function getRouterServerSnapshot(runtimeContext) {
+    return routerServerSnapshotExtension.get(runtimeContext);
+}
+function toHydrationScripts(state) {
+    if (state.hydrationScripts?.length) return state.hydrationScripts;
+    return state.hydrationScript ? [
+        state.hydrationScript
+    ] : void 0;
+}
+function getMatchedRouteIdsFromMatches(matches) {
+    const routeIds = matches?.map((match)=>match.assetRouteId ?? match.routeId).filter((routeId)=>'string' == typeof routeId);
+    return routeIds?.length ? routeIds : void 0;
+}
+function createRouterServerSnapshot(state) {
+    const hydrationScripts = toHydrationScripts(state);
+    const matchedRouteIds = state.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
+    return {
+        ...state,
+        ...hydrationScripts?.length ? {
+            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
+            hydrationScripts
+        } : {},
+        ...matchedRouteIds ? {
+            matchedRouteIds
+        } : {}
+    };
+}
+function createRouterRuntimeState(state) {
+    const hasSnapshotState = Boolean(state.serverSnapshot) || Boolean(state.hydrationScript) || Boolean(state.hydrationScripts?.length) || Boolean(state.matchedRouteIds?.length) || Boolean(state.matches?.length);
+    const serverSnapshot = state.serverSnapshot ? createRouterServerSnapshot({
+        ...state.serverSnapshot,
+        framework: state.serverSnapshot.framework ?? state.framework,
+        basename: state.serverSnapshot.basename ?? state.basename,
+        hydrationScript: state.serverSnapshot.hydrationScript ?? state.hydrationScript,
+        hydrationScripts: state.serverSnapshot.hydrationScripts ?? state.hydrationScripts,
+        matchedRouteIds: state.serverSnapshot.matchedRouteIds ?? state.matchedRouteIds,
+        matches: state.serverSnapshot.matches ?? state.matches
+    }) : hasSnapshotState ? createRouterServerSnapshot({
+        framework: state.framework,
+        basename: state.basename,
+        hydrationScript: state.hydrationScript,
+        hydrationScripts: state.hydrationScripts,
+        matchedRouteIds: state.matchedRouteIds,
+        matches: state.matches
+    }) : void 0;
+    const hydrationScripts = toHydrationScripts({
+        hydrationScript: state.hydrationScript ?? serverSnapshot?.hydrationScript,
+        hydrationScripts: state.hydrationScripts ?? serverSnapshot?.hydrationScripts
+    });
+    const matchedRouteIds = state.matchedRouteIds ?? serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
+    return {
+        ...state,
+        ...hydrationScripts?.length ? {
+            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
+            hydrationScripts
+        } : {},
+        ...matchedRouteIds ? {
+            matchedRouteIds
+        } : {},
+        ...serverSnapshot ? {
+            serverSnapshot
+        } : {}
+    };
+}
+function applyRouterRuntimeState(runtimeContext, state) {
+    const normalized = createRouterRuntimeState(state);
+    routerRuntimeStateExtension.set(runtimeContext, normalized);
+    if (normalized.serverSnapshot) routerServerSnapshotExtension.set(runtimeContext, normalized.serverSnapshot);
+    return runtimeContext;
+}
+function applyRouterServerPrepareResult(runtimeContext, result) {
+    const state = createRouterRuntimeState({
+        ...result.state,
+        cleanup: result.cleanup ?? result.state.cleanup,
+        serverSnapshot: result.snapshot ?? result.state.serverSnapshot
+    });
+    applyRouterRuntimeState(runtimeContext, state);
+    return runtimeContext;
+}
+function getRouterHydrationScripts(runtimeContext) {
+    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
+    const runtimeState = getRouterRuntimeState(runtimeContext);
+    return serverSnapshot?.hydrationScripts ?? toHydrationScripts({
+        hydrationScript: serverSnapshot?.hydrationScript
+    }) ?? runtimeState?.hydrationScripts ?? toHydrationScripts({
+        hydrationScript: runtimeState?.hydrationScript
+    }) ?? [];
+}
+function getRouterMatchedRouteIds(runtimeContext) {
+    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
+    const runtimeState = getRouterRuntimeState(runtimeContext);
+    return serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(serverSnapshot?.matches) ?? runtimeState?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeState?.matches);
+}
+async function cleanupRouterRuntimeState(runtimeContext) {
+    try {
+        await getRouterRuntimeState(runtimeContext)?.cleanup?.();
+    } catch  {}
+}
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot };

package/dist/esm/routerStatePlugin.mjs

@@ -0,0 +1,48 @@
+import { createRouterPrefetchPolicy } from "./routerPrefetchPolicy.mjs";
+import { applyRouterRuntimeState, createRouterServerSnapshot } from "./routerState.mjs";
+function createRouterStatePlugin({ registryHooks }) {
+    return {
+        name: '@modern-js/router-runtime-policy',
+        registryHooks,
+        setup (api) {
+            api.onBeforeRender((context)=>{
+                const runtimeContext = context;
+                runtimeContext.linkPrefetchPolicy ??= createRouterPrefetchPolicy();
+            });
+            api.onAfterCreateRouter((event)=>{
+                if ('react-router' !== event.framework) return;
+                if ('ssr-prepare' === event.phase) {
+                    const { routerContext } = event.runtimeContext;
+                    if (!routerContext) return;
+                    const serverSnapshot = createRouterServerSnapshot({
+                        framework: event.framework,
+                        basename: event.basename,
+                        statusCode: routerContext.statusCode,
+                        errors: routerContext.errors ?? void 0,
+                        routerData: {
+                            loaderData: routerContext.loaderData,
+                            errors: routerContext.errors ?? void 0
+                        },
+                        matches: routerContext.matches.flatMap((match)=>'string' == typeof match.route.id ? [
+                                {
+                                    routeId: match.route.id
+                                }
+                            ] : [])
+                    });
+                    applyRouterRuntimeState(event.runtimeContext, {
+                        framework: event.framework,
+                        basename: event.basename,
+                        instance: event.router,
+                        matchedRouteIds: serverSnapshot.matchedRouteIds,
+                        serverSnapshot
+                    });
+                } else if ('client-create' === event.phase) applyRouterRuntimeState(event.runtimeContext, {
+                    framework: event.framework,
+                    basename: event.basename,
+                    instance: event.router
+                });
+            });
+        }
+    };
+}
+export { createRouterStatePlugin };

package/dist/esm/runtimeContextProjection.mjs

@@ -0,0 +1,74 @@
+import { stripRuntimeContextExtensions } from "./contextExtensions.mjs";
+function createRscSafeRequestContext(ssrContext) {
+    const requestContext = {
+        request: {
+            params: {},
+            pathname: '',
+            query: {},
+            headers: {},
+            host: '',
+            url: ''
+        },
+        response: {
+            setHeader () {},
+            status () {},
+            locals: {}
+        }
+    };
+    Object.defineProperty(requestContext.response, 'setHeader', {
+        enumerable: false
+    });
+    Object.defineProperty(requestContext.response, 'status', {
+        enumerable: false
+    });
+    if (void 0 === ssrContext) return requestContext;
+    const { request, response } = ssrContext;
+    return {
+        request: {
+            url: request.url,
+            userAgent: request.userAgent,
+            cookie: request.cookie,
+            pathname: request.pathname,
+            query: {
+                ...request.query
+            },
+            params: {
+                ...request.params
+            },
+            headers: {
+                ...request.headers
+            },
+            host: request.host,
+            referer: request.referer
+        },
+        response: Object.assign(requestContext.response, {
+            locals: response.locals ?? {}
+        })
+    };
+}
+function projectRuntimeContext(projection, options) {
+    let internalContext = projection.internalContext;
+    let publicContext = {
+        ...projection.publicContext
+    };
+    stripRuntimeContextExtensions(publicContext);
+    if (options.isRsc && false === options.context.isBrowser) {
+        const requestContext = createRscSafeRequestContext(options.context.ssrContext);
+        internalContext = {
+            ...internalContext,
+            context: requestContext,
+            requestContext
+        };
+        delete internalContext.ssrContext;
+        publicContext = {
+            ...publicContext,
+            context: requestContext,
+            requestContext
+        };
+    }
+    return {
+        internalContext,
+        publicContext
+    };
+}
+export { projectRuntimeContext };

package/dist/esm/shellStream.mjs

@@ -12,7 +12,7 @@ const createConservingWebShellStream = (source, context, marker, onMissingMarker
         markerFound = candidate.includes(marker);
         markerCarry = markerFound ? '' : candidate.slice(-(marker.length - 1));
     };
-    return source.pipeThrough(new TransformStream({
+    const transform = new TransformStream({
         transform (chunk, controller) {
             const decoded = decoder.decode(chunk, {
                 stream: true
@@ -33,6 +33,38 @@ const createConservingWebShellStream = (source, context, marker, onMissingMarker
             const output = headProcessor.finish(decoded);
             if (output) controller.enqueue(encoder.encode(output));
         }
-    }));
+    });
+    const piping = source.pipeTo(transform.writable);
+    piping.catch(()=>{});
+    const reader = transform.readable.getReader();
+    return new ReadableStream({
+        async pull (controller) {
+            try {
+                const result = await reader.read();
+                if (result.done) {
+                    await piping;
+                    controller.close();
+                    reader.releaseLock();
+                } else controller.enqueue(result.value);
+            } catch (error) {
+                await piping.catch(()=>{});
+                controller.error(error);
+                reader.releaseLock();
+            }
+        },
+        async cancel (reason) {
+            try {
+                await reader.cancel(reason);
+            } finally{
+                try {
+                    await piping.catch((error)=>{
+                        if (error !== reason) throw error;
+                    });
+                } finally{
+                    reader.releaseLock();
+                }
+            }
+        }
+    });
 };
 export { createConservingWebShellStream };

package/dist/esm/workspaceEvents.mjs

@@ -0,0 +1,66 @@
+const ultramodernWorkspaceEventNames = {
+    navigate: 'ultramodern:navigate',
+    performanceSignal: 'ultramodern:performance-signal',
+    remoteReady: 'ultramodern:remote-ready',
+    routeSettled: 'ultramodern:route-settled'
+};
+class UltramodernWorkspaceEventValidationError {
+    constructor(eventName, payload){
+        this.name = 'UltramodernWorkspaceEventValidationError';
+        this.message = `Invalid payload for UltraModern workspace event "${eventName}"`;
+        this.eventName = eventName;
+        this.payload = payload;
+    }
+}
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isNonEmptyString = (value)=>'string' == typeof value && value.trim().length > 0;
+const isNonNegativeNumber = (value)=>'number' == typeof value && Number.isFinite(value) && value >= 0;
+const isUltramodernWorkspaceLocale = (value)=>'en' === value || 'cs' === value;
+const isPerformanceReadinessSignalId = (value)=>'bfcache' === value || 'core-web-vitals-rum' === value || 'duplicate-prefetch-warmup' === value || 'cache-policy-sanity' === value || 'save-data-behavior' === value || 'cloudflare-ssr-cache-hints' === value;
+const isPerformanceReadinessSignalStatus = (value)=>'pass' === value || 'warn' === value || 'fail' === value;
+const hasOptionalString = (value, key)=>void 0 === value[key] || isNonEmptyString(value[key]);
+const hasOptionalBoolean = (value, key)=>void 0 === value[key] || 'boolean' == typeof value[key];
+const hasOptionalRecord = (value, key)=>void 0 === value[key] || isRecord(value[key]);
+const hasOptionalNonNegativeNumber = (value, key)=>void 0 === value[key] || isNonNegativeNumber(value[key]);
+const hasOptionalLocale = (value, key)=>void 0 === value[key] || isUltramodernWorkspaceLocale(value[key]);
+const isUltramodernNavigatePayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.to) && hasOptionalBoolean(payload, 'replace') && hasOptionalRecord(payload, 'state');
+const isUltramodernRouteSettledPayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.pathname) && hasOptionalLocale(payload, 'locale') && hasOptionalString(payload, 'title');
+const isUltramodernRemoteReadyPayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.appId) && hasOptionalString(payload, 'build') && hasOptionalString(payload, 'surface') && hasOptionalString(payload, 'version');
+const isUltramodernPerformanceSignalPayload = (payload)=>isRecord(payload) && isPerformanceReadinessSignalId(payload.signalId) && isPerformanceReadinessSignalStatus(payload.status) && hasOptionalNonNegativeNumber(payload, 'durationMs') && hasOptionalRecord(payload, 'detail');
+const ultramodernWorkspaceEventValidators = {
+    [ultramodernWorkspaceEventNames.navigate]: isUltramodernNavigatePayload,
+    [ultramodernWorkspaceEventNames.performanceSignal]: isUltramodernPerformanceSignalPayload,
+    [ultramodernWorkspaceEventNames.remoteReady]: isUltramodernRemoteReadyPayload,
+    [ultramodernWorkspaceEventNames.routeSettled]: isUltramodernRouteSettledPayload
+};
+const isUltramodernWorkspaceEventPayload = (eventName, payload)=>ultramodernWorkspaceEventValidators[eventName](payload);
+const assertUltramodernWorkspaceEventPayload = (eventName, payload)=>{
+    if (!isUltramodernWorkspaceEventPayload(eventName, payload)) throw new UltramodernWorkspaceEventValidationError(eventName, payload);
+    return payload;
+};
+const createUltramodernWorkspaceEvent = (eventName, payload)=>new CustomEvent(eventName, {
+        bubbles: true,
+        composed: true,
+        detail: assertUltramodernWorkspaceEventPayload(eventName, payload)
+    });
+const dispatchUltramodernWorkspaceEvent = (target, eventName, payload)=>target.dispatchEvent(createUltramodernWorkspaceEvent(eventName, payload));
+const onUltramodernWorkspaceEvent = (target, eventName, handler)=>{
+    const listener = (event)=>{
+        if (!('detail' in event)) throw new UltramodernWorkspaceEventValidationError(eventName, void 0);
+        const customEvent = event;
+        handler(assertUltramodernWorkspaceEventPayload(eventName, customEvent.detail), customEvent);
+    };
+    target.addEventListener(eventName, listener);
+    return ()=>{
+        target.removeEventListener(eventName, listener);
+    };
+};
+const dispatchUltramodernNavigate = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.navigate, payload);
+const dispatchUltramodernRouteSettled = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.routeSettled, payload);
+const dispatchUltramodernRemoteReady = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.remoteReady, payload);
+const dispatchUltramodernPerformanceSignal = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.performanceSignal, payload);
+const onUltramodernNavigate = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.navigate, handler);
+const onUltramodernRouteSettled = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.routeSettled, handler);
+const onUltramodernRemoteReady = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.remoteReady, handler);
+const onUltramodernPerformanceSignal = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.performanceSignal, handler);
+export { UltramodernWorkspaceEventValidationError, assertUltramodernWorkspaceEventPayload, createUltramodernWorkspaceEvent, dispatchUltramodernNavigate, dispatchUltramodernPerformanceSignal, dispatchUltramodernRemoteReady, dispatchUltramodernRouteSettled, dispatchUltramodernWorkspaceEvent, isUltramodernNavigatePayload, isUltramodernPerformanceSignalPayload, isUltramodernRemoteReadyPayload, isUltramodernRouteSettledPayload, isUltramodernWorkspaceEventPayload, onUltramodernNavigate, onUltramodernPerformanceSignal, onUltramodernRemoteReady, onUltramodernRouteSettled, onUltramodernWorkspaceEvent, ultramodernWorkspaceEventNames };

package/dist/esm-node/contextExtensions.mjs

@@ -0,0 +1,34 @@
+import "node:module";
+const EXTENSIONS_SLOT = Symbol.for('@modern-js/runtime:context-extensions');
+function getStore(context) {
+    return context[EXTENSIONS_SLOT];
+}
+function ensureStore(context) {
+    const target = context;
+    const store = target[EXTENSIONS_SLOT] ?? new Map();
+    Object.defineProperty(target, EXTENSIONS_SLOT, {
+        configurable: true,
+        enumerable: true,
+        value: store
+    });
+    return store;
+}
+function stripRuntimeContextExtensions(context) {
+    delete context[EXTENSIONS_SLOT];
+}
+function createRuntimeContextExtension(id) {
+    const key = Symbol.for(`@modern-js/runtime:context-extension:${id}`);
+    return {
+        key,
+        get (context) {
+            return getStore(context)?.get(key);
+        },
+        set (context, value) {
+            ensureStore(context).set(key, value);
+        },
+        remove (context) {
+            getStore(context)?.delete(key);
+        }
+    };
+}
+export { createRuntimeContextExtension, stripRuntimeContextExtensions };

package/dist/esm-node/headRuntime.mjs

@@ -0,0 +1,44 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import react from "react";
+import { Helmet, HelmetProvider } from "react-helmet-async";
+import * as __rspack_external__rendererHead_mjs_b8160cc7 from "./rendererHead.mjs";
+function createHeadRuntime() {
+    const HeadContext = /*#__PURE__*/ react.createContext(void 0);
+    const collectServerHelmet = ({ runtimeContext, helmetContext }, props)=>{
+        const createRecord = ()=>__rspack_external__rendererHead_mjs_b8160cc7.createHelmetRecord(react, props);
+        const deriveState = (records)=>__rspack_external__rendererHead_mjs_b8160cc7.deriveHelmetServerState(react, records);
+        const marker = __rspack_external__rendererHead_mjs_b8160cc7.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
+        if (void 0 !== marker) return marker;
+        helmetContext.helmet = __rspack_external__rendererHead_mjs_b8160cc7.collectImmediateHelmetState(react, helmetContext, createRecord());
+    };
+    const Head = (props)=>{
+        const state = react.useContext(HeadContext);
+        if (void 0 !== state) return __rspack_external__rendererHead_mjs_b8160cc7.renderHeadMarker(react, collectServerHelmet(state, props));
+        return /*#__PURE__*/ react.createElement(Helmet, props);
+    };
+    const ClientRoot = ({ children })=>{
+        const state = react.useContext(HeadContext);
+        return void 0 === state ? /*#__PURE__*/ jsx(HelmetProvider, {
+            children: children
+        }) : children;
+    };
+    return {
+        Head,
+        wrapServerRoot (root, state) {
+            return /*#__PURE__*/ jsx(HeadContext.Provider, {
+                value: state,
+                children: /*#__PURE__*/ jsx(HelmetProvider, {
+                    context: state.helmetContext,
+                    children: root
+                })
+            });
+        },
+        wrapClientRoot (root) {
+            return /*#__PURE__*/ jsx(ClientRoot, {
+                children: root
+            });
+        }
+    };
+}
+export { createHeadRuntime };

package/dist/esm-node/helmetContext.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+import { createRuntimeContextExtension } from "./contextExtensions.mjs";
+const helmetContextExtension = createRuntimeContextExtension('@modern-js/runtime:helmet-context');
+function getHelmetContext(context) {
+    return helmetContextExtension.get(context);
+}
+function ensureHelmetContext(context) {
+    const existing = helmetContextExtension.get(context);
+    if (void 0 !== existing) return existing;
+    const created = {};
+    helmetContextExtension.set(context, created);
+    return created;
+}
+export { ensureHelmetContext, getHelmetContext };

package/dist/esm-node/index.mjs

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

package/dist/esm-node/prefetchPolicy.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+function resolvePreloadFromPrefetch(prefetch, preload) {
+    if (void 0 !== preload) return preload;
+    if ('none' === prefetch) return false;
+    if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
+    return 'viewport';
+}
+function normalizePreloadBehavior(preload, prefetch) {
+    const resolved = resolvePreloadFromPrefetch(prefetch, preload);
+    return false === resolved ? 'none' : resolved;
+}
+export { normalizePreloadBehavior, resolvePreloadFromPrefetch };

package/dist/esm-node/request-policy/browser.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+import { createClient } from "@modern-js/create-request/client";
+import { createPolicyClient } from "./client.mjs";
+export * from "./requestContext.mjs";
+export * from "./types.mjs";
+const browser_createClient = ()=>createPolicyClient(createClient(), {
+        target: 'browser',
+        resolveSourceOrigin: ()=>"u" > typeof window ? window.location.origin : void 0
+    });
+const { configure: configure, createRequest: createRequest, createUploader: createUploader } = browser_createClient();
+export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError } from "./policyCore.mjs";
+export { browser_createClient as createClient, configure, createRequest, createUploader };