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

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

@@ -0,0 +1,104 @@
+import "node:module";
+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-node/module-federation/renderer-runtime-plugin.mjs

@@ -0,0 +1,223 @@
+import "node:module";
+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-node/module-federation/telemetry.mjs

@@ -0,0 +1,143 @@
+import "node:module";
+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/types/module-federation/consume-surface.d.ts

@@ -22,8 +22,8 @@
  * consumption during a rollout window should be driven by expand/contract, not
  * by silent degrade.
  */
-import { type ModuleFederationFallbackClassification, type ModuleFederationFallbackTelemetryEmitOptions, type ModuleFederationFallbackTelemetryPayload } from './index.js';
 import { type DiscoveryError, type EnvironmentId, type ParsedSurfaceRef, type ResolvedDeliveryUnit, type SurfaceResolutionProvider } from './surface-resolution-types.js';
+import { type ModuleFederationFallbackClassification, type ModuleFederationFallbackTelemetryEmitOptions, type ModuleFederationFallbackTelemetryPayload } from './telemetry.js';
 /** Where in the consumption lifecycle a failure was raised. */
 export type SurfaceConsumptionPhase = 'discovery' | 'load' | 'mount';
 /**
@@ -76,7 +76,7 @@ export type SurfaceConsumerOptions<T> = {
      * omitted.
      *
      * - `'noncritical'`: the degraded handler's result is returned and the
-     *   failure is swallowed — the promise never rejects.
+     *   failure is swallowed — a failed degraded handler resolves undefined.
      * - `'critical'`: the degraded handler still runs (telemetry + fallback-UI
      *   obligations hold), but the returned promise then REJECTS with the typed
      *   failure so callers / rollout machinery observe it. Prefer expand/contract
@@ -91,14 +91,14 @@ export type SurfaceConsumerOptions<T> = {
  * load failure the required degraded handler runs (telemetry + fallback UI).
  *
  * For a `noncritical` consumption (see {@link SurfaceConsumerOptions.classification})
- * this resolves to the degraded value and never rejects, so a failing
+ * this resolves to the degraded value (or undefined if the handler fails), so a failing
  * consumption is isolated from any sibling. For a `critical` consumption (the
  * default) it rejects with the typed failure AFTER the degraded handler has
  * run, so callers / rollout machinery observe the failure.
  */
-export declare function consumeSurface<T>(options: SurfaceConsumerOptions<T>): Promise<T>;
+export declare function consumeSurface<T>(options: SurfaceConsumerOptions<T>): Promise<T | undefined>;
 /**
  * Build a reusable consumer bound to a provider/env/app, still requiring a
  * degraded handler per call. Per-call options override the bound base.
  */
-export declare function createSurfaceConsumer(base: Pick<SurfaceConsumerOptions<unknown>, 'provider' | 'env' | 'appName' | 'telemetry'>): <T>(options: Omit<SurfaceConsumerOptions<T>, keyof typeof base> & Partial<Pick<SurfaceConsumerOptions<T>, keyof typeof base>>) => Promise<T>;
+export declare function createSurfaceConsumer(base: Pick<SurfaceConsumerOptions<unknown>, 'provider' | 'env' | 'appName' | 'telemetry'>): <T>(options: Omit<SurfaceConsumerOptions<T>, keyof typeof base> & Partial<Pick<SurfaceConsumerOptions<T>, keyof typeof base>>) => Promise<T | undefined>;

package/dist/types/module-federation/distributed-ssr.d.ts

@@ -30,8 +30,25 @@ export type DistributedSsrBoundaryProps<Props extends object = Record<string, un
     fragmentProps?: Props;
     remote: string;
 };
+/**
+ * The Module Federation `createLazyComponent` options the distributed boundary
+ * owns. `injectLink` is always false: the boundary owns remote CSS (the
+ * fragment CSS inventory in workerd, the MF manifest in the browser), so the
+ * bridge must not render a second `<link>` in SSR HTML.
+ */
+export type DistributedSsrLazyComponentOptions = {
+    export: 'default';
+    fallback: ReactNode;
+    injectLink: false;
+    loading: null;
+};
 export type CreateDistributedSsrComponentOptions<Props extends object> = {
-    createComponent: () => ComponentType<Props>;
+    /**
+     * Creates the native remote on first render. Spread `options` into
+     * Module Federation's `createLazyComponent` and add the instance and
+     * loader.
+     */
+    createComponent: (options: DistributedSsrLazyComponentOptions) => ComponentType<Props>;
     expose: string;
     fallback: ReactNode;
     remote: string;

package/dist/types/module-federation/index.d.ts

@@ -1,71 +1,5 @@
 export * from './consume-surface.js';
-export * from './distributed-ssr.js';
-export { DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, useDistributedSsrFragmentProps, } from './distributed-ssr.js';
 export * from './last-known-good.js';
 export * from './manifest-recovery-runtime-plugin.js';
 export * from './surface-resolution-types.js';
-export declare const MODULE_FEDERATION_FALLBACK_SIGNAL_EVENT = "modernjs:mf-runtime-fallback";
-export declare const MODULE_FEDERATION_RECOVERY_SIGNAL_EVENT = "modernjs:mf-runtime-recovery";
-export declare const DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = "/_modern/contract-gates/runtime-fallback";
-export declare const DEFAULT_RUNTIME_FALLBACK_SIGNAL_AUTH_HEADER = "x-modernjs-runtime-signal-token";
-export type ModuleFederationFallbackClassification = 'timeout' | 'network' | 'contract' | 'version-skew' | 'remote-unavailable';
-export type ModuleFederationFallbackStatus = 'degraded' | 'failed' | 'recovered';
-export type ModuleFederationFallbackTelemetryInput = {
-    appName: string;
-    classification: ModuleFederationFallbackClassification;
-    entry?: string;
-    error?: unknown;
-    eventName?: string;
-    exportName?: string;
-    metadata?: Record<string, unknown>;
-    phase: 'discovery' | 'load' | 'mount' | 'hydrate' | 'recover';
-    remote: string;
-    runtimeDigest?: string;
-    status?: ModuleFederationFallbackStatus;
-};
-export type ModuleFederationFallbackTelemetryPayload = {
-    appName: string;
-    entry?: string;
-    eventName: string;
-    phase: ModuleFederationFallbackTelemetryInput['phase'];
-    reason: ModuleFederationFallbackClassification;
-    runtimeDigest?: string;
-    schemaVersion: 1;
-    metadata: {
-        classification: ModuleFederationFallbackClassification;
-        errorMessage?: string;
-        errorName?: string;
-        exportName?: string;
-        remote: string;
-        runtimeDigest?: string;
-        status: ModuleFederationFallbackStatus;
-    } & Record<string, unknown>;
-};
-export type ModuleFederationFallbackTelemetryEmitOptions = {
-    authHeaderName?: string;
-    authToken?: string;
-    endpoint?: string;
-    fetchImpl?: typeof fetch;
-    postSignal?: boolean;
-};
-export type ModuleFederationFallbackTelemetryEmitResult = {
-    dispatched: boolean;
-    posted: boolean;
-    postStatus?: number;
-};
-export declare class ModuleFederationRemoteLoadTimeoutError extends Error {
-    constructor(remote: string, timeoutMs: number);
-}
-export declare class ModuleFederationRemoteLoadError extends Error {
-    readonly remote: string;
-    readonly attempts: number;
-    readonly causeError: Error;
-    constructor(remote: string, attempts: number, causeError: Error);
-}
-export declare class ModuleFederationRemoteComponentContractError extends Error {
-    constructor(remote: string, exportName: string);
-}
-export declare function classifyModuleFederationFallback(error: unknown): ModuleFederationFallbackClassification;
-export declare function createModuleFederationFallbackTelemetry(input: ModuleFederationFallbackTelemetryInput): ModuleFederationFallbackTelemetryPayload;
-export declare function toModuleFederationFallbackAttributes(payload: ModuleFederationFallbackTelemetryPayload): Record<string, string>;
-export declare function emitModuleFederationFallbackTelemetry(input: ModuleFederationFallbackTelemetryInput, options?: ModuleFederationFallbackTelemetryEmitOptions): Promise<ModuleFederationFallbackTelemetryEmitResult>;
+export * from './telemetry.js';

package/dist/types/module-federation/renderer-contract.d.ts

@@ -0,0 +1,20 @@
+import { type RendererIdentity, type RendererPackageIdentity, type RendererProfile } from '@modern-js/backend-federation-contracts';
+export declare const RENDERER_FEDERATION_METADATA_KEY = "ultramodernRenderer";
+export declare const RENDERER_FEDERATION_SCHEMA = "ultramodern.renderer-federation";
+export declare const RENDERER_FEDERATION_SCHEMA_VERSION = 1;
+/** The consuming renderer tuple; application and source identities are independent. */
+export interface RendererFederationCompatibility {
+    readonly profile: RendererProfile;
+    readonly runtime: RendererPackageIdentity;
+    readonly bootstrap: RendererPackageIdentity;
+}
+/** Finalized native build authority for both browser and SSR remote entries. */
+export interface RendererFederationContract extends RendererFederationCompatibility {
+    readonly schema: typeof RENDERER_FEDERATION_SCHEMA;
+    readonly schemaVersion: typeof RENDERER_FEDERATION_SCHEMA_VERSION;
+    readonly identities: Readonly<Record<string, RendererIdentity>>;
+}
+export declare const rendererFederationError: (message: string) => Error;
+export declare function readRendererFederationCompatibility(value: unknown): RendererFederationCompatibility;
+export declare function readRendererFederationContract(value: unknown): RendererFederationContract;
+export declare function assertRendererFederationCompatibility(expected: RendererFederationCompatibility, actual: RendererFederationCompatibility): void;