@bleedingdev/modern-js-federation-runtime 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/esm/module-federation/renderer-contract.mjs

@@ -0,0 +1,103 @@
+import { assertRendererProfileCompatibility, formatBackendFederationValidationErrors, validateRendererIdentity, validateRendererProfile } from "@modern-js/backend-federation-contracts";
+const RENDERER_FEDERATION_METADATA_KEY = 'ultramodernRenderer';
+const RENDERER_FEDERATION_SCHEMA = 'ultramodern.renderer-federation';
+const RENDERER_FEDERATION_SCHEMA_VERSION = 1;
+const rendererFederationError = (message)=>new Error(`Renderer federation manifest contract: ${message}`);
+const record = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+const exactFields = (value, fields, label)=>{
+    const unknown = Object.keys(value).filter((key)=>!fields.includes(key));
+    const missing = fields.filter((key)=>!Object.hasOwn(value, key));
+    if (unknown.length || missing.length) throw rendererFederationError(`${label} fields differ (unknown=${unknown.join(',')}; missing=${missing.join(',')}).`);
+};
+const assertProfile = (value)=>{
+    const result = validateRendererProfile(value, 'rendererProfile');
+    if (!result.ok) throw rendererFederationError(formatBackendFederationValidationErrors(result.errors));
+    const profile = value;
+    return Object.freeze({
+        ...profile,
+        compiler: Object.freeze({
+            ...profile.compiler
+        }),
+        hydration: Object.freeze({
+            ...profile.hydration
+        }),
+        router: Object.freeze({
+            ...profile.router
+        })
+    });
+};
+const assertPackage = (value, profile, label)=>{
+    const result = validateRendererProfile({
+        ...profile,
+        compiler: value
+    }, label);
+    if (!result.ok) throw rendererFederationError(formatBackendFederationValidationErrors(result.errors));
+    return Object.freeze({
+        ...value
+    });
+};
+function readRendererFederationCompatibility(value) {
+    if (!record(value)) throw rendererFederationError('the consuming renderer tuple is absent.');
+    exactFields(value, [
+        'profile',
+        'runtime',
+        'bootstrap'
+    ], 'compatibility');
+    const profile = assertProfile(value.profile);
+    return Object.freeze({
+        profile,
+        runtime: assertPackage(value.runtime, profile, 'runtime'),
+        bootstrap: assertPackage(value.bootstrap, profile, 'bootstrap')
+    });
+}
+function readRendererFederationContract(value) {
+    if (!record(value)) throw rendererFederationError('renderer publication metadata is absent.');
+    exactFields(value, [
+        'schema',
+        'schemaVersion',
+        'profile',
+        'runtime',
+        'bootstrap',
+        'identities'
+    ], 'publication');
+    if (value.schema !== RENDERER_FEDERATION_SCHEMA || value.schemaVersion !== RENDERER_FEDERATION_SCHEMA_VERSION) throw rendererFederationError('unsupported renderer publication schema.');
+    const compatibility = readRendererFederationCompatibility({
+        profile: value.profile,
+        runtime: value.runtime,
+        bootstrap: value.bootstrap
+    });
+    if (!record(value.identities) || !Object.keys(value.identities).length) throw rendererFederationError('finalized application entry identities are absent.');
+    const identities = Object.create(null);
+    let appId;
+    for (const [entryName, valueIdentity] of Object.entries(value.identities)){
+        const result = validateRendererIdentity(valueIdentity, `identities.${entryName}`);
+        if (!result.ok) throw rendererFederationError(formatBackendFederationValidationErrors(result.errors));
+        const identity = valueIdentity;
+        if (identity.entryName !== entryName || identity.renderer !== compatibility.profile.renderer || identity.protocolVersion !== compatibility.profile.protocolVersion || void 0 !== appId && identity.appId !== appId) throw rendererFederationError(`incoherent publication identity for ${entryName}.`);
+        appId = identity.appId;
+        identities[entryName] = Object.freeze({
+            ...identity
+        });
+    }
+    return Object.freeze({
+        schema: RENDERER_FEDERATION_SCHEMA,
+        schemaVersion: RENDERER_FEDERATION_SCHEMA_VERSION,
+        ...compatibility,
+        identities: Object.freeze(identities)
+    });
+}
+function assertRendererFederationCompatibility(expected, actual) {
+    try {
+        assertRendererProfileCompatibility(expected.profile, actual.profile);
+    } catch (error) {
+        throw rendererFederationError(error instanceof Error ? error.message : String(error));
+    }
+    for (const field of [
+        'runtime',
+        'bootstrap'
+    ])for (const key of [
+        'name',
+        'version'
+    ])if (expected[field][key] !== actual[field][key]) throw rendererFederationError(`${field}.${key} must match the consuming renderer tuple.`);
+}
+export { RENDERER_FEDERATION_METADATA_KEY, RENDERER_FEDERATION_SCHEMA, RENDERER_FEDERATION_SCHEMA_VERSION, assertRendererFederationCompatibility, readRendererFederationCompatibility, readRendererFederationContract, rendererFederationError };

package/dist/esm/module-federation/renderer-runtime-plugin.mjs

@@ -0,0 +1,222 @@
+import { getResourceUrl, isBrowserEnvValue, isReactNativeEnv } from "@module-federation/sdk";
+import { RENDERER_FEDERATION_METADATA_KEY, assertRendererFederationCompatibility, readRendererFederationCompatibility, readRendererFederationContract, rendererFederationError } from "./renderer-contract.mjs";
+const ATTESTATION = Symbol.for('ultramodern.renderer-federation.attestation.v1');
+const record = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+const coordinates = (snapshot)=>JSON.stringify([
+        'globalName',
+        'buildVersion',
+        'remoteEntry',
+        'remoteEntryType',
+        'ssrRemoteEntry',
+        'ssrRemoteEntryType',
+        'publicPath',
+        'ssrPublicPath',
+        'getPublicPath'
+    ].map((key)=>[
+            key,
+            snapshot[key]
+        ]));
+function attestation(snapshot) {
+    const descriptor = Object.getOwnPropertyDescriptor(snapshot, ATTESTATION);
+    const value = descriptor?.value;
+    if (!descriptor || descriptor.writable || descriptor.configurable || !record(value) || 'string' != typeof value.coordinates || value.coordinates !== coordinates(snapshot)) throw rendererFederationError('cached remote snapshot is missing or has changed its attestation.');
+    return {
+        contract: readRendererFederationContract(value.contract),
+        coordinates: value.coordinates
+    };
+}
+const assertManifestRemote = (remote)=>{
+    if (!record(remote)) throw rendererFederationError('remote registration is absent.');
+    if ('entry' in remote && ('string' != typeof remote.entry || !remote.entry.includes('.json'))) throw rendererFederationError('renderer components require a native JSON manifest remote.');
+};
+function sameFactory(left, right) {
+    if (left === right) return true;
+    if ('function' == typeof left.lib && 'function' == typeof right.lib) return left.lib === right.lib;
+    return 'function' == typeof left.get && left.get === right.get;
+}
+const containerCoordinates = (info)=>JSON.stringify([
+        'name',
+        'entry',
+        'type',
+        'entryGlobalName',
+        'buildVersion'
+    ].map((key)=>[
+            key,
+            info[key]
+        ]));
+const entryCoordinates = (info)=>JSON.stringify([
+        'name',
+        'entry',
+        'type',
+        'entryGlobalName'
+    ].map((key)=>[
+            key,
+            info[key]
+        ]));
+function rendererShareVersions(expected) {
+    const { profile, runtime, bootstrap } = expected;
+    if ('react' === profile.renderer) return new Map([
+        [
+            'react',
+            runtime.version
+        ],
+        [
+            'react-dom',
+            profile.hydration.version
+        ],
+        [
+            'react-dom/client',
+            profile.hydration.version
+        ],
+        [
+            '@modern-js/runtime',
+            bootstrap.version
+        ]
+    ]);
+    const versions = new Map();
+    for (const [name, version] of [
+        [
+            runtime.name,
+            runtime.version
+        ],
+        [
+            profile.hydration.name,
+            profile.hydration.version
+        ],
+        [
+            bootstrap.name,
+            bootstrap.version
+        ],
+        [
+            profile.router.name,
+            profile.router.version
+        ],
+        [
+            profile.router.coreName,
+            profile.router.coreVersion
+        ]
+    ]){
+        const prior = versions.get(name);
+        if (void 0 !== prior && prior !== version) throw rendererFederationError(`renderer tuple names ${name} with conflicting versions.`);
+        versions.set(name, version);
+    }
+    return versions;
+}
+function createRendererFederationRuntimePlugin(options) {
+    const expected = readRendererFederationCompatibility(options);
+    const selected = new Map();
+    const approvedRemoteInfos = new WeakMap();
+    const observedEntries = new WeakMap();
+    const acceptedEntries = new Set();
+    const versions = rendererShareVersions(expected);
+    return {
+        name: 'ultramodern-renderer-federation-contract',
+        beforeRegisterRemote (args) {
+            assertManifestRemote(args.remote);
+            return args;
+        },
+        async afterMatchRemote (args) {
+            if (!args.error) assertManifestRemote(args.remote);
+            return args;
+        },
+        async loadRemoteSnapshot (args) {
+            const snapshot = args.remoteSnapshot;
+            if ('manifest' === args.from) {
+                const manifest = args.manifestJson;
+                const metadata = record(manifest) && record(manifest.metaData) ? manifest.metaData[RENDERER_FEDERATION_METADATA_KEY] : void 0;
+                const contract = readRendererFederationContract(metadata);
+                if (!record(snapshot) || 'string' != typeof snapshot.remoteEntry) throw rendererFederationError('native remote entry coordinates are absent.');
+                const existing = Object.getOwnPropertyDescriptor(snapshot, ATTESTATION);
+                if (existing) {
+                    const prior = attestation(snapshot);
+                    if (JSON.stringify(prior.contract) !== JSON.stringify(contract)) throw rendererFederationError('remote snapshot has conflicting publication ownership.');
+                } else Object.defineProperty(snapshot, ATTESTATION, {
+                    value: Object.freeze({
+                        contract,
+                        coordinates: coordinates(snapshot)
+                    })
+                });
+            } else assertRendererFederationCompatibility(expected, attestation(snapshot).contract);
+            return args;
+        },
+        async afterLoadSnapshot (args) {
+            assertRendererFederationCompatibility(expected, attestation(args.remoteSnapshot).contract);
+            const snapshot = args.remoteSnapshot;
+            const browser = isBrowserEnvValue || isReactNativeEnv() || !('ssrRemoteEntry' in snapshot);
+            const entry = browser ? snapshot.remoteEntry : snapshot.ssrRemoteEntry;
+            if ('string' != typeof entry || !entry) throw rendererFederationError('native projected remote entry is absent.');
+            let entryUrl = getResourceUrl(snapshot, entry);
+            if (!isBrowserEnvValue && !entryUrl.startsWith('http')) entryUrl = `https:${entryUrl}`;
+            acceptedEntries.add(entryCoordinates({
+                name: args.moduleInfo?.name ?? snapshot.globalName,
+                entry: entryUrl,
+                type: browser ? snapshot.remoteEntryType : snapshot.ssrRemoteEntryType || 'global',
+                entryGlobalName: snapshot.globalName
+            }));
+            return args;
+        },
+        async afterResolve (args) {
+            if (!args.remoteSnapshot) throw rendererFederationError('native remote resolution has no attested snapshot.');
+            assertRendererFederationCompatibility(expected, attestation(args.remoteSnapshot).contract);
+            const cached = args.origin.moduleCache.get(args.remote.name);
+            if (cached && (approvedRemoteInfos.get(cached.remoteInfo) !== containerCoordinates(cached.remoteInfo) || containerCoordinates(cached.remoteInfo) !== containerCoordinates(args.remoteInfo))) throw rendererFederationError('cached remote container has unattested or conflicting ownership.');
+            const priorCoordinates = approvedRemoteInfos.get(args.remoteInfo);
+            if (void 0 !== priorCoordinates && priorCoordinates !== containerCoordinates(args.remoteInfo)) throw rendererFederationError('native remote container coordinates changed after attestation.');
+            approvedRemoteInfos.set(args.remoteInfo, containerCoordinates(args.remoteInfo));
+            return args;
+        },
+        loadEntry (args) {
+            if (!acceptedEntries.has(entryCoordinates(args.remoteInfo))) throw rendererFederationError('remote entry coordinates differ from the attested native snapshot.');
+        },
+        async afterLoadEntry (args) {
+            if (args.error && !args.recovered) return args;
+            const binding = containerCoordinates(args.remoteInfo);
+            const entryBinding = entryCoordinates(args.remoteInfo);
+            if (args.cached && approvedRemoteInfos.get(args.remoteInfo) !== binding) throw rendererFederationError('remote entry has no attested native container resolution.');
+            if (!acceptedEntries.has(entryBinding)) throw rendererFederationError('remote entry coordinates differ from the attested native snapshot.');
+            const entry = args.remoteEntryExports;
+            if (('object' != typeof entry || null === entry) && 'function' != typeof entry) throw rendererFederationError('native container exports are absent.');
+            if (args.cached && observedEntries.get(entry) !== entryBinding) throw rendererFederationError('cached native container exports have unattested ownership.');
+            approvedRemoteInfos.set(args.remoteInfo, binding);
+            observedEntries.set(entry, entryBinding);
+            return args;
+        },
+        resolveShare (args) {
+            const version = versions.get(args.pkgName);
+            if (void 0 === version) return args;
+            const resolve = args.resolver;
+            return {
+                ...args,
+                resolver () {
+                    const result = resolve();
+                    if (!result) return result;
+                    const shared = result.useTreesShaking && record(result.shared.treeShaking) ? result.shared.treeShaking : result.shared;
+                    if (result.shared.version !== version) throw rendererFederationError(`shared ${args.pkgName} version must be ${version}.`);
+                    const prior = selected.get(args.pkgName);
+                    if (prior && !sameFactory(prior, shared)) throw rendererFederationError(`shared ${args.pkgName} has conflicting runtime ownership.`);
+                    for (const scope of Object.values(args.shareScopeMap))for (const candidate of Object.values(scope[args.pkgName] ?? {})){
+                        const active = record(candidate.treeShaking) && candidate.treeShaking.loaded ? candidate.treeShaking : candidate;
+                        if ((active.loaded || active.lib) && !sameFactory(active, shared)) throw rendererFederationError(`shared ${args.pkgName} has duplicate loaded runtime identities.`);
+                    }
+                    selected.set(args.pkgName, Object.freeze({
+                        lib: shared.lib,
+                        get: shared.get
+                    }));
+                    return result;
+                }
+            };
+        },
+        afterLoadShare (args) {
+            if (versions.has(args.pkgName) && args.selectedShared) {
+                const shared = record(args.selectedShared.treeShaking) && args.selectedShared.treeShaking.loaded ? args.selectedShared.treeShaking : args.selectedShared;
+                selected.set(args.pkgName, Object.freeze({
+                    lib: shared.lib,
+                    get: shared.get
+                }));
+            }
+        }
+    };
+}
+const renderer_runtime_plugin = createRendererFederationRuntimePlugin;
+export default renderer_runtime_plugin;
+export { createRendererFederationRuntimePlugin, rendererShareVersions };

package/dist/esm/module-federation/telemetry.mjs

@@ -0,0 +1,142 @@
+const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
+const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
+const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
+class ModuleFederationRemoteLoadTimeoutError extends Error {
+    constructor(remote, timeoutMs){
+        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
+        this.name = 'ModuleFederationRemoteLoadTimeoutError';
+    }
+}
+class ModuleFederationRemoteLoadError extends Error {
+    constructor(remote, attempts, causeError){
+        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
+        this.name = 'ModuleFederationRemoteLoadError';
+        this.remote = remote;
+        this.attempts = attempts;
+        this.causeError = causeError;
+    }
+}
+class ModuleFederationRemoteComponentContractError extends Error {
+    constructor(remote, exportName){
+        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
+        this.name = 'ModuleFederationRemoteComponentContractError';
+    }
+}
+function toError(error) {
+    if (error instanceof Error) return error;
+    return new Error('string' == typeof error ? error : 'Unknown remote load error');
+}
+function classifyModuleFederationFallback(error) {
+    const normalizedError = toError(error);
+    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
+    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
+    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
+    const message = normalizedError.message;
+    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
+    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
+    return 'remote-unavailable';
+}
+function createModuleFederationFallbackTelemetry(input) {
+    const error = void 0 !== input.error ? toError(input.error) : void 0;
+    const status = input.status ?? 'degraded';
+    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
+    const metadata = {
+        ...input.metadata ?? {},
+        classification: input.classification,
+        remote: input.remote,
+        status
+    };
+    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
+    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
+    if (void 0 !== error) {
+        metadata.errorName = error.name;
+        metadata.errorMessage = error.message;
+    }
+    const payload = {
+        appName: input.appName,
+        eventName,
+        metadata,
+        phase: input.phase,
+        reason: input.classification,
+        schemaVersion: 1
+    };
+    if (void 0 !== input.entry) payload.entry = input.entry;
+    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
+    return payload;
+}
+function toModuleFederationFallbackAttributes(payload) {
+    return {
+        'data-mf-fallback-app': payload.appName,
+        'data-mf-fallback-classification': payload.reason,
+        'data-mf-fallback-phase': payload.phase,
+        'data-mf-fallback-remote': String(payload.metadata.remote),
+        'data-mf-fallback-status': String(payload.metadata.status),
+        'data-mf-telemetry-event': payload.eventName
+    };
+}
+function emitModuleFederationFallbackTelemetry(input, options = {}) {
+    return emitModuleFederationFallbackPayload(createModuleFederationFallbackTelemetry(input), options);
+}
+function emitModuleFederationFallbackPayload(payload, options = {}) {
+    const delivery = deliver(payload, options);
+    try {
+        options.observe?.(payload, delivery);
+    } catch  {}
+    return delivery;
+}
+async function deliver(payload, options) {
+    let dispatched = false;
+    let timer;
+    const controller = new AbortController();
+    try {
+        if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) {
+            window.dispatchEvent(new CustomEvent(payload.eventName, {
+                detail: payload
+            }));
+            dispatched = true;
+        }
+        const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+        if (!(true === options.postSignal || options.endpoint) || 'function' != typeof fetchImpl) return {
+            dispatched,
+            posted: false
+        };
+        const headers = new Headers({
+            'content-type': 'application/json'
+        });
+        if (options.authToken) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
+        const timeoutMs = Number.isSafeInteger(options.timeoutMs) && (options.timeoutMs ?? 0) > 0 ? options.timeoutMs : 1000;
+        const expired = new Promise((resolve)=>{
+            timer = setTimeout(()=>{
+                controller.abort();
+                resolve(void 0);
+            }, timeoutMs);
+        });
+        const response = await Promise.race([
+            fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
+                body: JSON.stringify(payload),
+                headers,
+                method: 'POST',
+                keepalive: true,
+                signal: controller.signal
+            }),
+            expired
+        ]);
+        return response ? {
+            dispatched,
+            posted: true,
+            postStatus: response.status
+        } : {
+            dispatched,
+            posted: false
+        };
+    } catch  {
+        return {
+            dispatched,
+            posted: false
+        };
+    } finally{
+        if (void 0 !== timer) clearTimeout(timer);
+    }
+}
+export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackPayload, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };

package/dist/esm-node/module-federation/consume-surface.mjs

@@ -1,6 +1,6 @@
 import "node:module";
-import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry } from "./index.mjs";
 import { createDiscoveryError, formatSurfaceRef, parseSurfaceRef, validateSurfaceRef } from "./surface-resolution-types.mjs";
+import { classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackPayload, emitModuleFederationFallbackTelemetry } from "./telemetry.mjs";
 function classifyDiscoveryError(code) {
     switch(code){
         case 'major-not-published':
@@ -39,17 +39,7 @@ async function reportFailure(options, ref, base) {
         remote,
         status: 'degraded'
     });
-    try {
-        await emitModuleFederationFallbackTelemetry({
-            appName: options.appName,
-            classification: base.classification,
-            error: base.error ?? base.discoveryError,
-            metadata: telemetry.metadata,
-            phase: base.phase,
-            remote,
-            status: 'degraded'
-        }, options.telemetry ?? {});
-    } catch  {}
+    emitModuleFederationFallbackPayload(telemetry, options.telemetry);
     const failure = {
         ref,
         env: options.env,
@@ -69,7 +59,7 @@ async function reportFailure(options, ref, base) {
         degradedValue = await options.degraded(failure);
     } catch (handlerError) {
         try {
-            await emitModuleFederationFallbackTelemetry({
+            emitModuleFederationFallbackTelemetry({
                 appName: options.appName,
                 classification: base.classification,
                 error: handlerError,

package/dist/esm-node/module-federation/distributed-ssr.mjs

@@ -63,7 +63,12 @@ function DistributedSsrBoundary({ children, expose, fallback, fragmentProps, rem
 function createDistributedSsrComponent({ createComponent, expose, fallback, remote }) {
     let RemoteComponent;
     function DeferredRemoteComponent(props) {
-        RemoteComponent ??= createComponent();
+        RemoteComponent ??= createComponent({
+            export: 'default',
+            fallback,
+            injectLink: false,
+            loading: null
+        });
         return /*#__PURE__*/ jsx(RemoteComponent, {
             ...props
         });

package/dist/esm-node/module-federation/index.mjs

@@ -1,116 +1,6 @@
 import "node:module";
 export * from "./consume-surface.mjs";
-export * from "./distributed-ssr.mjs";
 export * from "./last-known-good.mjs";
 export * from "./manifest-recovery-runtime-plugin.mjs";
 export * from "./surface-resolution-types.mjs";
-const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = 'modernjs:mf-runtime-fallback';
-const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = 'modernjs:mf-runtime-recovery';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = '/_modern/contract-gates/runtime-fallback';
-const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = 'x-modernjs-runtime-signal-token';
-class ModuleFederationRemoteLoadTimeoutError extends Error {
-    constructor(remote, timeoutMs){
-        super(`Loading remote "${remote}" timed out after ${timeoutMs}ms`);
-        this.name = 'ModuleFederationRemoteLoadTimeoutError';
-    }
-}
-class ModuleFederationRemoteLoadError extends Error {
-    constructor(remote, attempts, causeError){
-        super(`Unable to load remote "${remote}" after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${causeError.message}`);
-        this.name = 'ModuleFederationRemoteLoadError';
-        this.remote = remote;
-        this.attempts = attempts;
-        this.causeError = causeError;
-    }
-}
-class ModuleFederationRemoteComponentContractError extends Error {
-    constructor(remote, exportName){
-        super(`Remote "${remote}" export "${exportName}" is not a valid React component`);
-        this.name = 'ModuleFederationRemoteComponentContractError';
-    }
-}
-function toError(error) {
-    if (error instanceof Error) return error;
-    return new Error('string' == typeof error ? error : 'Unknown remote load error');
-}
-function classifyModuleFederationFallback(error) {
-    const normalizedError = toError(error);
-    if (normalizedError instanceof ModuleFederationRemoteLoadError) return classifyModuleFederationFallback(normalizedError.causeError);
-    if (normalizedError instanceof ModuleFederationRemoteLoadTimeoutError) return 'timeout';
-    if (normalizedError instanceof ModuleFederationRemoteComponentContractError) return 'contract';
-    const message = normalizedError.message;
-    if (/version|requiredVersion|singleton|share scope|shared module/i.test(message)) return 'version-skew';
-    if (/network|fetch|script|timeout|chunk|loading/i.test(message)) return 'network';
-    return 'remote-unavailable';
-}
-function createModuleFederationFallbackTelemetry(input) {
-    const error = void 0 !== input.error ? toError(input.error) : void 0;
-    const status = input.status ?? 'degraded';
-    const eventName = input.eventName ?? ('recovered' === status ? MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT : MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT);
-    const metadata = {
-        ...input.metadata ?? {},
-        classification: input.classification,
-        remote: input.remote,
-        status
-    };
-    if (void 0 !== input.exportName) metadata.exportName = input.exportName;
-    if (void 0 !== input.runtimeDigest) metadata.runtimeDigest = input.runtimeDigest;
-    if (void 0 !== error) {
-        metadata.errorName = error.name;
-        metadata.errorMessage = error.message;
-    }
-    const payload = {
-        appName: input.appName,
-        eventName,
-        metadata,
-        phase: input.phase,
-        reason: input.classification,
-        schemaVersion: 1
-    };
-    if (void 0 !== input.entry) payload.entry = input.entry;
-    if (void 0 !== input.runtimeDigest) payload.runtimeDigest = input.runtimeDigest;
-    return payload;
-}
-function toModuleFederationFallbackAttributes(payload) {
-    return {
-        'data-mf-fallback-app': payload.appName,
-        'data-mf-fallback-classification': payload.reason,
-        'data-mf-fallback-phase': payload.phase,
-        'data-mf-fallback-remote': String(payload.metadata.remote),
-        'data-mf-fallback-status': String(payload.metadata.status),
-        'data-mf-telemetry-event': payload.eventName
-    };
-}
-async function emitModuleFederationFallbackTelemetry(input, options = {}) {
-    const payload = createModuleFederationFallbackTelemetry(input);
-    if ("u" > typeof window && 'function' == typeof window.dispatchEvent && "u" > typeof CustomEvent) window.dispatchEvent(new CustomEvent(payload.eventName, {
-        detail: payload
-    }));
-    const shouldPost = true === options.postSignal || Boolean(options.endpoint);
-    if (!shouldPost) return {
-        dispatched: true,
-        posted: false
-    };
-    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-    if ('function' != typeof fetchImpl) return {
-        dispatched: true,
-        posted: false
-    };
-    const headers = new Headers({
-        'content-type': 'application/json'
-    });
-    if (void 0 !== options.authToken && options.authToken.length > 0) headers.set(options.authHeaderName ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, options.authToken);
-    const response = await fetchImpl(options.endpoint ?? DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, {
-        body: JSON.stringify(payload),
-        headers,
-        method: 'POST',
-        keepalive: true
-    });
-    return {
-        dispatched: true,
-        posted: true,
-        postStatus: response.status
-    };
-}
-export { DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, useDistributedSsrFragmentProps } from "./distributed-ssr.mjs";
-export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT, MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT, ModuleFederationRemoteComponentContractError, ModuleFederationRemoteLoadError, ModuleFederationRemoteLoadTimeoutError, classifyModuleFederationFallback, createModuleFederationFallbackTelemetry, emitModuleFederationFallbackTelemetry, toModuleFederationFallbackAttributes };
+export * from "./telemetry.mjs";

package/dist/esm-node/module-federation/manifest-recovery-runtime-plugin.mjs

@@ -32,7 +32,7 @@ const getErrorStatus = (error)=>{
     if ('object' == typeof error && null !== error && 'status' in error && 'number' == typeof error.status) return error.status;
 };
 const isRetryableError = (error)=>{
-    if (error instanceof SyntaxError) return false;
+    if (error instanceof SyntaxError) return true;
     const message = getErrorMessage(error);
     if (NON_RETRYABLE_ERROR_PATTERNS.some((pattern)=>pattern.test(message))) return false;
     const status = getErrorStatus(error);