@bleedingdev/modern-js-runtime 3.5.0-ultramodern.10 → 3.5.0-ultramodern.101

package/dist/cjs/core/server/requestResponse.js

@@ -0,0 +1,83 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    applyRouterSnapshotResult: ()=>applyRouterSnapshotResult,
+    createLoaderRedirectResponse: ()=>createLoaderRedirectResponse,
+    finalizeRenderResponse: ()=>finalizeRenderResponse
+});
+const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
+const rsc_router_js_namespaceObject = require("../../router/runtime/rsc-router.js");
+const external_tracer_js_namespaceObject = require("./tracer.js");
+const isRedirectStatus = (status)=>status >= 300 && status <= 399;
+const isNullBodyStatus = (status)=>204 === status || 205 === status || 304 === status;
+const processRedirect = (headers, status, ctx)=>{
+    if (ctx.enableRsc && ctx.isRSCNavigation) return (0, rsc_router_js_namespaceObject.handleRSCRedirect)(headers, ctx.basename, status);
+    return new Response(null, {
+        status,
+        headers
+    });
+};
+const applyRouterSnapshotResult = (context, onError)=>{
+    const routerServerSnapshot = (0, lifecycle_js_namespaceObject.getRouterServerSnapshot)(context);
+    const routerStatusCode = routerServerSnapshot?.statusCode ?? context.routerContext?.statusCode;
+    if (routerStatusCode && 200 !== routerStatusCode) context.ssrContext?.response.status(routerStatusCode);
+    const errors = Object.values(routerServerSnapshot?.errors || context.routerContext?.errors || {});
+    if (errors.length > 0) onError(errors[0], external_tracer_js_namespaceObject.SSRErrors.LOADER_ERROR);
+};
+const createLoaderRedirectResponse = (beforeRenderResult, redirectCtx)=>{
+    if (!beforeRenderResult || !isRedirectStatus(beforeRenderResult.status)) return;
+    if (beforeRenderResult.headers.has('X-Modernjs-Redirect')) return beforeRenderResult;
+    const redirectUrl = beforeRenderResult.headers.get('Location') || '/';
+    return processRedirect(new Headers({
+        Location: redirectUrl
+    }), beforeRenderResult.status, redirectCtx);
+};
+const finalizeRenderResponse = (response, responseProxy, redirectCtx, routerCleanup)=>{
+    if (-1 !== responseProxy.status && isRedirectStatus(responseProxy.status) && responseProxy.headers.Location) return processRedirect(new Headers(responseProxy.headers), responseProxy.status, redirectCtx);
+    Object.entries(responseProxy.headers).forEach(([key, value])=>{
+        response.headers.set(key, value);
+    });
+    if (-1 !== responseProxy.status) return routerCleanup.deferUntilBodyDone(new Response(isNullBodyStatus(responseProxy.status) ? null : response.body, {
+        status: responseProxy.status,
+        headers: response.headers
+    }));
+    return routerCleanup.deferUntilBodyDone(response);
+};
+exports.applyRouterSnapshotResult = __webpack_exports__.applyRouterSnapshotResult;
+exports.createLoaderRedirectResponse = __webpack_exports__.createLoaderRedirectResponse;
+exports.finalizeRenderResponse = __webpack_exports__.finalizeRenderResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRouterSnapshotResult",
+    "createLoaderRedirectResponse",
+    "finalizeRenderResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/server/routerCleanup.js

@@ -30,14 +30,22 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     ROUTER_CLEANUP_ERROR: ()=>ROUTER_CLEANUP_ERROR,
     createRouterCleanup: ()=>createRouterCleanup,
-    withRouterCleanup: ()=>withRouterCleanup
+    finishWithRouterCleanup: ()=>finishWithRouterCleanup,
+    runWithRouterCleanupOnError: ()=>runWithRouterCleanupOnError
 });
 const lifecycle_js_namespaceObject = require("../../router/runtime/lifecycle.js");
 const ROUTER_CLEANUP_ERROR = 'An error occurs during router runtime cleanup';
-async function withRouterCleanup(runtimeContext, onError, callback) {
-    const routerCleanup = createRouterCleanup(runtimeContext, onError);
+async function runWithRouterCleanupOnError(routerCleanup, callback) {
     try {
-        return await callback(routerCleanup);
+        return await callback();
+    } catch (error) {
+        await routerCleanup.run();
+        throw error;
+    }
+}
+async function finishWithRouterCleanup(routerCleanup, callback) {
+    try {
+        return await callback();
     } finally{
         if (!routerCleanup.deferred) await routerCleanup.run();
     }
@@ -99,11 +107,13 @@ function createRouterCleanup(runtimeContext, onError) {
 }
 exports.ROUTER_CLEANUP_ERROR = __webpack_exports__.ROUTER_CLEANUP_ERROR;
 exports.createRouterCleanup = __webpack_exports__.createRouterCleanup;
-exports.withRouterCleanup = __webpack_exports__.withRouterCleanup;
+exports.finishWithRouterCleanup = __webpack_exports__.finishWithRouterCleanup;
+exports.runWithRouterCleanupOnError = __webpack_exports__.runWithRouterCleanupOnError;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ROUTER_CLEANUP_ERROR",
     "createRouterCleanup",
-    "withRouterCleanup"
+    "finishWithRouterCleanup",
+    "runWithRouterCleanupOnError"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/core/server/scriptOrder.js

@@ -29,7 +29,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createRouteHydrationScriptTags: ()=>createRouteHydrationScriptTags,
-    getMatchedRouteAssets: ()=>getMatchedRouteAssets,
+    getMatchedRouteChunks: ()=>getMatchedRouteChunks,
     injectBeforeHydrationEntryScript: ()=>injectBeforeHydrationEntryScript,
     orderHydrationScriptChunks: ()=>orderHydrationScriptChunks,
     replaceChunkJsPlaceholder: ()=>replaceChunkJsPlaceholder
@@ -78,6 +78,10 @@ function getMatchedRouteAssets(runtimeContext, routeManifest) {
     const matchedRouteIds = (0, lifecycle_js_namespaceObject.getRouterMatchedRouteIds)(runtimeContext) ?? [];
     return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []);
 }
+function getMatchedRouteChunks(runtimeContext, routeManifest, routeAssetToChunk) {
+    if (!routeManifest) return [];
+    return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
+}
 const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
     const asyncEntryScriptChunks = [];
     const asyncEntryDependencyChunks = [];
@@ -108,23 +112,22 @@ function createRouteHydrationScriptTags(runtimeContext, entryName, options = {})
     const { nonce, template } = options;
     const routeAssets = getRouteAssets(runtimeContext);
     if (void 0 === routeAssets) return '';
-    const matchedRouteIds = (0, lifecycle_js_namespaceObject.getRouterMatchedRouteIds)(runtimeContext) ?? [];
-    const assetEntries = [
-        ...matchedRouteIds.map((routeId)=>routeAssets[routeId]),
-        routeAssets[`async-${entryName}`]
-    ].filter((entry)=>void 0 !== entry);
-    const jsAssets = Array.from(new Set(assetEntries.flatMap((entry)=>(entry.assets ?? []).filter((asset)=>asset.endsWith('.js')))));
+    const existingScriptSrcs = void 0 === template ? new Set() : new Set(getScriptTags(template).map(({ src })=>src));
+    const jsAssets = Array.from(new Set([
+        ...getMatchedRouteAssets(runtimeContext),
+        ...routeAssets[`async-${entryName}`]?.assets ?? []
+    ].filter((asset)=>asset.endsWith('.js'))));
     const nonceAttr = void 0 === nonce || '' === nonce ? '' : ` nonce="${nonce}"`;
-    return jsAssets.filter((asset)=>template?.includes(asset) !== true).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
+    return jsAssets.filter((asset)=>!existingScriptSrcs.has(asset)).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
 }
 exports.createRouteHydrationScriptTags = __webpack_exports__.createRouteHydrationScriptTags;
-exports.getMatchedRouteAssets = __webpack_exports__.getMatchedRouteAssets;
+exports.getMatchedRouteChunks = __webpack_exports__.getMatchedRouteChunks;
 exports.injectBeforeHydrationEntryScript = __webpack_exports__.injectBeforeHydrationEntryScript;
 exports.orderHydrationScriptChunks = __webpack_exports__.orderHydrationScriptChunks;
 exports.replaceChunkJsPlaceholder = __webpack_exports__.replaceChunkJsPlaceholder;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createRouteHydrationScriptTags",
-    "getMatchedRouteAssets",
+    "getMatchedRouteChunks",
     "injectBeforeHydrationEntryScript",
     "orderHydrationScriptChunks",
     "replaceChunkJsPlaceholder"

package/dist/cjs/core/server/stream/afterTemplate.js

@@ -40,15 +40,16 @@ const external_utils_js_namespaceObject = require("../utils.js");
 function buildShellAfterTemplate(afterAppTemplate, options) {
     const { request, config, ssrConfig, runtimeContext, renderLevel, entryName } = options;
     const callbacks = [
+        (template)=>injectJs(template, entryName, config.nonce),
         createReplaceSSRData({
             request,
             ssrConfig,
             nonce: config.nonce,
             useJsonScript: config.useJsonScript,
             runtimeContext,
-            renderLevel
-        }),
-        (template)=>injectJs(template, entryName, config.nonce)
+            renderLevel,
+            entryName
+        })
     ];
     async function injectJs(template, entryName, nonce) {
         const jsChunkStr = (0, external_scriptOrder_js_namespaceObject.createRouteHydrationScriptTags)(runtimeContext, entryName, {
@@ -61,7 +62,7 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
     return (0, external_shared_js_namespaceObject.buildHtml)(afterAppTemplate, callbacks);
 }
 function createReplaceSSRData(options) {
-    const { runtimeContext, nonce, renderLevel, useJsonScript, ssrConfig } = options;
+    const { runtimeContext, nonce, renderLevel, useJsonScript, ssrConfig, entryName } = options;
     const { request, reporter } = runtimeContext.ssrContext;
     const headers = 'object' == typeof ssrConfig && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _])=>ssrConfig.unsafeHeaders?.map((header)=>header.toLowerCase())?.includes(key.toLowerCase()))) : void 0;
     const ssrData = {
@@ -92,7 +93,10 @@ function createReplaceSSRData(options) {
     const ssrDataScript = useJsonScript ? `<script type="application/json" id="${external_constants_js_namespaceObject.SSR_DATA_JSON_ID}">${serializeSSRData}</script>` : `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>`;
     const hydrationScripts = (0, lifecycle_js_namespaceObject.getRouterHydrationScripts)(runtimeContext);
     const ssrScripts = hydrationScripts.length ? `${ssrDataScript}\n${hydrationScripts.join('\n')}` : ssrDataScript;
-    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER, ssrScripts);
+    return (template)=>{
+        if (!template.includes(external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER)) return template;
+        return (0, external_scriptOrder_js_namespaceObject.replaceChunkJsPlaceholder)(template, ssrScripts, entryName, external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER);
+    };
 }
 exports.buildShellAfterTemplate = __webpack_exports__.buildShellAfterTemplate;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/core/server/stream/template.js

@@ -34,12 +34,12 @@ const external_afterTemplate_js_namespaceObject = require("./afterTemplate.js");
 const external_beforeTemplate_js_namespaceObject = require("./beforeTemplate.js");
 const HTML_SEPARATOR = '<!--<?- html ?>-->';
 const getTemplates = async (htmlTemplate, options)=>{
-    const [beforeAppTemplate = '', afterAppHtmlTemplate = ''] = htmlTemplate.split(HTML_SEPARATOR) || [];
+    const builtTemplate = await (0, external_afterTemplate_js_namespaceObject.buildShellAfterTemplate)(htmlTemplate, options);
+    const [beforeAppTemplate = '', afterAppHtmlTemplate = ''] = builtTemplate.split(HTML_SEPARATOR) || [];
     const builtBeforeTemplate = await (0, external_beforeTemplate_js_namespaceObject.buildShellBeforeTemplate)(beforeAppTemplate, options);
-    const builtAfterTemplate = await (0, external_afterTemplate_js_namespaceObject.buildShellAfterTemplate)(afterAppHtmlTemplate, options);
     return {
         shellBefore: builtBeforeTemplate,
-        shellAfter: builtAfterTemplate
+        shellAfter: afterAppHtmlTemplate
     };
 };
 exports.getTemplates = __webpack_exports__.getTemplates;

package/dist/cjs/core/server/string/index.js

@@ -127,7 +127,7 @@ async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifie
         createReplaceHtml(html),
         createReplaceChunkJs(jsChunk, entryName),
         createReplaceChunkCss(cssChunk),
-        createReplaceSSRDataScript(ssrScripts),
+        createReplaceSSRDataScript(ssrScripts, entryName),
         (0, external_helmet_js_namespaceObject.createReplaceHelemt)(helmetData),
         ...htmlModifiers
     ]);
@@ -136,8 +136,8 @@ async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifie
 function createReplaceHtml(html) {
     return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.HTML_PLACEHOLDER, html);
 }
-function createReplaceSSRDataScript(data) {
-    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER, data);
+function createReplaceSSRDataScript(data, entryName) {
+    return (template)=>(0, external_scriptOrder_js_namespaceObject.replaceChunkJsPlaceholder)(template, data, entryName, external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER);
 }
 function createReplaceChunkJs(js, entryName) {
     return (template)=>(0, external_scriptOrder_js_namespaceObject.replaceChunkJsPlaceholder)(template, js, entryName);

package/dist/cjs/core/server/string/loadable.js

@@ -28,8 +28,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    LoadableCollector: ()=>LoadableCollector,
-    orderHydrationScriptChunks: ()=>external_scriptOrder_js_namespaceObject.orderHydrationScriptChunks
+    LoadableCollector: ()=>LoadableCollector
 });
 const server_namespaceObject = require("@loadable/server");
 const external_federatedCss_js_namespaceObject = require("../federatedCss.js");
@@ -61,11 +60,6 @@ const readAsset = async (chunk)=>{
     return fs.readFile(filepath, 'utf-8');
 };
 class LoadableCollector {
-    getMatchedRouteChunks() {
-        const { routeManifest, runtimeContext } = this.options;
-        if (!routeManifest) return [];
-        return (0, external_scriptOrder_js_namespaceObject.getMatchedRouteAssets)(runtimeContext, routeManifest).map(routeAssetToChunk);
-    }
     collect(comopnent) {
         const { stats, entryName } = this.options;
         if (!stats) return comopnent;
@@ -87,7 +81,7 @@ class LoadableCollector {
             ]));
         } catch (e) {}
         const collectedChunks = extractor ? extractor.getChunkAssets(extractor.chunks) : [];
-        const matchedRouteChunks = this.getMatchedRouteChunks();
+        const matchedRouteChunks = (0, external_scriptOrder_js_namespaceObject.getMatchedRouteChunks)(options.runtimeContext, options.routeManifest, routeAssetToChunk);
         const orderedScriptChunks = (0, external_scriptOrder_js_namespaceObject.orderHydrationScriptChunks)({
             asyncEntryChunks: asyncChunks,
             collectedChunks,
@@ -166,10 +160,8 @@ class LoadableCollector {
     }
 }
 exports.LoadableCollector = __webpack_exports__.LoadableCollector;
-exports.orderHydrationScriptChunks = __webpack_exports__.orderHydrationScriptChunks;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "LoadableCollector",
-    "orderHydrationScriptChunks"
+    "LoadableCollector"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/document/cli/index.js

@@ -39,7 +39,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     default: ()=>cli,
     documentPlugin: ()=>documentPlugin,
-    getDocumentByEntryName: ()=>getDocumentByEntryName
+    getDocumentByEntryName: ()=>getDocumentByEntryName,
+    processScriptPlaceholders: ()=>processScriptPlaceholders
 });
 const utils_namespaceObject = require("@modern-js/utils");
 const external_entities_namespaceObject = require("entities");
@@ -394,10 +395,12 @@ const cli = documentPlugin;
 exports["default"] = __webpack_exports__["default"];
 exports.documentPlugin = __webpack_exports__.documentPlugin;
 exports.getDocumentByEntryName = __webpack_exports__.getDocumentByEntryName;
+exports.processScriptPlaceholders = __webpack_exports__.processScriptPlaceholders;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "default",
     "documentPlugin",
-    "getDocumentByEntryName"
+    "getDocumentByEntryName",
+    "processScriptPlaceholders"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/index.js

@@ -28,19 +28,20 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    RuntimeContext: ()=>index_js_namespaceObject.RuntimeContext,
-    defineRuntimeConfig: ()=>index_js_namespaceObject.defineRuntimeConfig,
-    getMonitors: ()=>monitors_index_js_namespaceObject.getMonitors,
+    RuntimeContext: ()=>public_js_namespaceObject.RuntimeContext,
+    defineRuntimeConfig: ()=>config_js_namespaceObject.defineRuntimeConfig,
+    getMonitors: ()=>index_js_namespaceObject.getMonitors,
     getRequest: ()=>request_index_js_namespaceObject.getRequest,
     isBrowser: ()=>external_common_js_namespaceObject.isBrowser,
     redirect: ()=>response_index_js_namespaceObject.redirect,
     setHeaders: ()=>response_index_js_namespaceObject.setHeaders,
     setStatus: ()=>response_index_js_namespaceObject.setStatus,
-    useRuntimeContext: ()=>index_js_namespaceObject.useRuntimeContext
+    useRuntimeContext: ()=>public_js_namespaceObject.useRuntimeContext
 });
 const external_common_js_namespaceObject = require("./common.js");
-const index_js_namespaceObject = require("./core/index.js");
-const monitors_index_js_namespaceObject = require("./core/context/monitors/index.js");
+const config_js_namespaceObject = require("./core/config.js");
+const index_js_namespaceObject = require("./core/context/monitors/index.js");
+const public_js_namespaceObject = require("./core/context/public.js");
 const request_index_js_namespaceObject = require("./core/context/request/index.js");
 const response_index_js_namespaceObject = require("./core/context/response/index.js");
 exports.RuntimeContext = __webpack_exports__.RuntimeContext;

package/dist/cjs/module-federation/consume-surface.js

@@ -0,0 +1,199 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    consumeSurface: ()=>consumeSurface,
+    createSurfaceConsumer: ()=>createSurfaceConsumer
+});
+const external_index_js_namespaceObject = require("./index.js");
+const external_surface_resolution_types_js_namespaceObject = require("./surface-resolution-types.js");
+function classifyDiscoveryError(code) {
+    switch(code){
+        case 'major-not-published':
+        case 'stale-record':
+            return 'version-skew';
+        case 'identity-mismatch':
+            return 'contract';
+        case 'unknown-unit':
+        case 'unknown-surface':
+        case 'provider-unavailable':
+            return 'remote-unavailable';
+        default:
+            return 'remote-unavailable';
+    }
+}
+function toRemoteString(ref) {
+    return void 0 === (0, external_surface_resolution_types_js_namespaceObject.validateSurfaceRef)(ref) ? (0, external_surface_resolution_types_js_namespaceObject.formatSurfaceRef)(ref) : `${ref.unitId}#${ref.surfaceId}`;
+}
+async function reportFailure(options, ref, base) {
+    const remote = toRemoteString(ref);
+    const telemetry = (0, external_index_js_namespaceObject.createModuleFederationFallbackTelemetry)({
+        appName: options.appName,
+        classification: base.classification,
+        error: base.error ?? base.discoveryError,
+        metadata: {
+            env: options.env,
+            surfaceRef: remote,
+            ...base.discoveryError ? {
+                discoveryErrorCode: base.discoveryError.code
+            } : {},
+            ...base.resolved ? {
+                buildMarker: base.resolved.buildMarker
+            } : {}
+        },
+        phase: base.phase,
+        remote,
+        status: 'degraded'
+    });
+    try {
+        await (0, external_index_js_namespaceObject.emitModuleFederationFallbackTelemetry)({
+            appName: options.appName,
+            classification: base.classification,
+            error: base.error ?? base.discoveryError,
+            metadata: telemetry.metadata,
+            phase: base.phase,
+            remote,
+            status: 'degraded'
+        }, options.telemetry ?? {});
+    } catch  {}
+    const failure = {
+        ref,
+        env: options.env,
+        phase: base.phase,
+        classification: base.classification,
+        telemetry
+    };
+    if (base.discoveryError) failure.discoveryError = base.discoveryError;
+    if (void 0 !== base.error) failure.error = base.error;
+    if (base.resolved) failure.resolved = base.resolved;
+    const critical = (options.classification ?? 'critical') === 'critical';
+    const reason = base.discoveryError ?? (void 0 !== base.error ? base.error : (0, external_surface_resolution_types_js_namespaceObject.createDiscoveryError)('identity-mismatch', remote, `resolved record for "${remote}" is incompatible`, {
+        env: options.env
+    }));
+    let degradedValue;
+    try {
+        degradedValue = await options.degraded(failure);
+    } catch (handlerError) {
+        try {
+            await (0, external_index_js_namespaceObject.emitModuleFederationFallbackTelemetry)({
+                appName: options.appName,
+                classification: base.classification,
+                error: handlerError,
+                metadata: {
+                    ...telemetry.metadata,
+                    degradedHandlerFailed: true
+                },
+                phase: base.phase,
+                remote,
+                status: 'failed'
+            }, options.telemetry ?? {});
+        } catch  {}
+        if (critical) throw reason;
+        return;
+    }
+    if (critical) throw reason;
+    return degradedValue;
+}
+async function consumeSurface(options) {
+    let ref;
+    if ('string' == typeof options.ref) {
+        const parsed = (0, external_surface_resolution_types_js_namespaceObject.parseSurfaceRef)(options.ref);
+        if (!parsed.ok) {
+            const hashIndex = options.ref.indexOf('#');
+            const echoed = -1 === hashIndex ? {
+                unitId: options.ref,
+                surfaceId: ''
+            } : {
+                unitId: options.ref.slice(0, hashIndex),
+                surfaceId: options.ref.slice(hashIndex + 1)
+            };
+            return reportFailure(options, echoed, {
+                phase: 'discovery',
+                classification: 'remote-unavailable',
+                discoveryError: (0, external_surface_resolution_types_js_namespaceObject.createDiscoveryError)('unknown-surface', options.ref, `SurfaceRef "${options.ref}" is not a valid canonical reference (${parsed.error.code}).`, {
+                    parseError: parsed.error,
+                    env: options.env
+                })
+            });
+        }
+        ref = parsed.ref;
+    } else ref = options.ref;
+    let resolution;
+    try {
+        resolution = await options.provider.resolve(ref, options.env);
+    } catch (error) {
+        return reportFailure(options, ref, {
+            phase: 'discovery',
+            classification: (0, external_index_js_namespaceObject.classifyModuleFederationFallback)(error),
+            error
+        });
+    }
+    if (!resolution.ok) return reportFailure(options, ref, {
+        phase: 'discovery',
+        classification: classifyDiscoveryError(resolution.error.code),
+        discoveryError: resolution.error
+    });
+    const resolved = resolution.unit;
+    if ('incompatible' === resolved.compatibility.status) return reportFailure(options, ref, {
+        phase: 'discovery',
+        classification: 'contract',
+        resolved
+    });
+    try {
+        return await options.load({
+            resolved,
+            ref,
+            env: options.env
+        });
+    } catch (error) {
+        return reportFailure(options, ref, {
+            phase: 'load',
+            classification: (0, external_index_js_namespaceObject.classifyModuleFederationFallback)(error),
+            error,
+            resolved
+        });
+    }
+}
+function createSurfaceConsumer(base) {
+    return function(options) {
+        return consumeSurface({
+            ...base,
+            ...options
+        });
+    };
+}
+exports.consumeSurface = __webpack_exports__.consumeSurface;
+exports.createSurfaceConsumer = __webpack_exports__.createSurfaceConsumer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "consumeSurface",
+    "createSurfaceConsumer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});