@bleedingdev/modern-js-runtime 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/esm-node/router/runtime/lifecycle.mjs

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

package/dist/esm-node/router/runtime/provider.mjs

@@ -1,101 +0,0 @@
-import "node:module";
-import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
-const routerProviderRegistryHooks = {
-    modifyRoutes: modifyRoutes,
-    onBeforeCreateRoutes: onBeforeCreateRoutes,
-    onBeforeCreateRouter: onBeforeCreateRouter,
-    onAfterCreateRouter: onAfterCreateRouter,
-    onBeforeHydrateRouter: onBeforeHydrateRouter,
-    onAfterHydrateRouter: onAfterHydrateRouter
-};
-function reportUnsupportedProviderRegistryHooks(providerPlugin) {
-    const unsupportedHookNames = Object.keys(providerPlugin.registryHooks ?? {}).filter((hookName)=>!(hookName in routerProviderRegistryHooks));
-    if (unsupportedHookNames.length > 0) console.warn(`[@modern-js/runtime] The router provider "${providerPlugin.name}" declares registry hooks outside the router hook contract: ${unsupportedHookNames.join(', ')}. These hooks are not registered when the provider is resolved through \`runtime.router.framework\` — declare them on a separate runtime plugin instead.`);
-    return unsupportedHookNames;
-}
-function createRouterProviderRealm(registrations) {
-    const providers = new Map();
-    let defaultProvider;
-    for (const registration of registrations){
-        if (0 === registration.name.length) throw new Error('[@modern-js/runtime] A router provider realm cannot contain an unnamed provider.');
-        if (providers.has(registration.name)) throw new Error(`[@modern-js/runtime] Router provider "${registration.name}" is declared more than once in the same runtime realm.`);
-        if (true === registration.isDefault && void 0 !== defaultProvider && defaultProvider !== registration.name) throw new Error(`[@modern-js/runtime] Router provider realm declares both "${defaultProvider}" and "${registration.name}" as defaults.`);
-        providers.set(registration.name, registration.factory);
-        if (true === registration.isDefault) defaultProvider = registration.name;
-    }
-    const providerNames = Object.freeze([
-        ...providers.keys()
-    ]);
-    return Object.freeze({
-        ...void 0 !== defaultProvider ? {
-            defaultProvider
-        } : {},
-        get: (name)=>providers.get(name),
-        names: ()=>providerNames
-    });
-}
-const REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v3');
-const LEGACY_V2_REGISTRY_SLOT = Symbol.for('@modern-js/runtime:router-providers:v2');
-function getRegistry() {
-    const host = globalThis;
-    host[REGISTRY_SLOT] ??= {
-        providers: new Map(),
-        duplicateProviders: new Set(),
-        warnedDuplicates: new Set()
-    };
-    host[REGISTRY_SLOT].duplicateProviders ??= new Set();
-    host[REGISTRY_SLOT].warnedDuplicates ??= new Set();
-    return host[REGISTRY_SLOT];
-}
-function getLegacyV2Registry() {
-    const host = globalThis;
-    return host[LEGACY_V2_REGISTRY_SLOT];
-}
-function registerRouterProvider(name, factory, options = {}) {
-    const registry = getRegistry();
-    const existing = registry.providers.get(name);
-    if (void 0 !== existing) {
-        if (existing !== factory) registry.duplicateProviders.add(name);
-        return;
-    }
-    if (true === options.isDefault) registry.defaultProvider = name;
-    registry.providers.set(name, factory);
-}
-function resolveRouterProvider(framework, options = {}) {
-    if (void 0 !== options.realm) {
-        const name = framework || options.realm.defaultProvider;
-        const realmProviderNames = options.realm.names();
-        if (void 0 === name) throw new Error(`[@modern-js/runtime] The app-owned router provider realm does not declare a default provider. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}.`);
-        const factory = options.realm.get(name);
-        if (void 0 === factory) throw new Error(`[@modern-js/runtime] Router provider "${name}" is not registered in the app-owned router provider realm. Available realm providers: ${realmProviderNames.join(', ') || '(none)'}. Compatibility registry fallback is disabled for app-owned realms.`);
-        return factory;
-    }
-    const registry = getRegistry();
-    const legacyV2Registry = getLegacyV2Registry();
-    const name = framework || options.localDefault?.name || registry.defaultProvider || legacyV2Registry?.defaultProvider;
-    if (void 0 === name) throw new Error('[@modern-js/runtime] No default router provider is registered. This is a bug in the runtime setup.');
-    if (void 0 !== options.localDefault && name === options.localDefault.name) return options.localDefault.factory;
-    const factory = registry.providers.get(name);
-    if (void 0 !== factory) {
-        if (registry.duplicateProviders.has(name) && !registry.warnedDuplicates.has(name)) {
-            registry.warnedDuplicates.add(name);
-            console.warn(`[@modern-js/runtime] The router provider "${name}" was registered more than once with different module instances, and a router wrapper without an app-owned provider realm is resolving the mixed-version compatibility fallback. The fallback is keeping the first registration. Modern router wrappers isolate app-owned realms automatically. For an older wrapper, share the provider runtime between Module Federation host and remotes or upgrade every app to a realm-aware runtime.`);
-        }
-        return factory;
-    }
-    const legacyV2Factory = legacyV2Registry?.providers.get(name);
-    if (void 0 !== legacyV2Factory) return legacyV2Factory;
-    if ('tanstack' === name) throw new Error("[@modern-js/runtime] `runtime.router.framework` is set to \"tanstack\", but no TanStack router provider is registered. Install @modern-js/plugin-tanstack, add `tanstackRouterPlugin()` to the `plugins` array in modern.config.ts, and make sure '@modern-js/plugin-tanstack/runtime' is imported (e.g. in modern.runtime.ts).");
-    throw new Error(`[@modern-js/runtime] Unknown router framework "${name}". Registered providers: ${[
-        ...new Set([
-            ...registry.providers.keys(),
-            ...legacyV2Registry?.providers.keys() ?? []
-        ])
-    ].join(', ') || '(none)'}. Install and register the plugin that provides this router framework.`);
-}
-function unsafe_resetRouterProvidersForTesting() {
-    const host = globalThis;
-    delete host[REGISTRY_SLOT];
-    delete host[LEGACY_V2_REGISTRY_SLOT];
-}
-export { createRouterProviderRealm, registerRouterProvider, reportUnsupportedProviderRegistryHooks, resolveRouterProvider, routerProviderRegistryHooks, unsafe_resetRouterProvidersForTesting };

package/dist/esm-node/rsc/server.worker.mjs

@@ -1,2 +0,0 @@
-import "node:module";
-export * from "@modern-js/render/rsc-worker";

package/dist/types/boundary-debugger/index.d.ts

@@ -1,28 +0,0 @@
-import type { RuntimePlugin } from '../common.js';
-export type BoundaryDebugEntry = {
-    appId: string;
-    color?: string;
-    label?: string;
-    mfName: string;
-    ownerTeam?: string;
-    packageName?: string;
-    role?: 'host' | 'vertical';
-};
-export type BoundaryDebugMetadata = {
-    appId: string;
-    boundaries: BoundaryDebugEntry[];
-    schemaVersion: 1;
-};
-export type BoundaryDebuggerControlMode = 'visible' | 'hidden-when-off' | 'hidden';
-export type BoundaryDebuggerPluginOptions = {
-    controlMode?: BoundaryDebuggerControlMode;
-    enabledByDefault?: boolean;
-    labels?: Record<string, {
-        toggle: string;
-    }>;
-    legacySelector?: string;
-    metadata: BoundaryDebugMetadata;
-    storageKey?: string;
-};
-export declare const ultramodernBoundaryDebuggerPlugin: (options: BoundaryDebuggerPluginOptions) => RuntimePlugin;
-export default ultramodernBoundaryDebuggerPlugin;

package/dist/types/core/context/extensions.d.ts

@@ -1,35 +0,0 @@
-/**
- * Fork-owned runtime-context extension mechanism.
- *
- * Plugins must not add ad-hoc fields to `TRuntimeContext` /
- * `TInternalRuntimeContext`. Instead they store state in a single internal
- * slot (a `Map` keyed by symbol) attached to the context object under a
- * symbol property, so nothing leaks into string-key enumeration
- * (`Object.keys`, `JSON.stringify`, `{ ...context }` rest patterns over
- * named keys).
- *
- * `Symbol.for` is used for both the slot and the extension keys so that the
- * mechanism stays coherent even if this module is instantiated twice
- * (e.g. esm/cjs interop in test runners).
- */
-export interface RuntimeContextExtension<T> {
-    /** Stable identity of this extension. */
-    readonly key: symbol;
-    get(context: object): T | undefined;
-    set(context: object, value: T): void;
-    remove(context: object): void;
-}
-/**
- * Removes the extension slot from a context object.
- *
- * The symbol slot crosses object spreads while remaining absent from string-key
- * enumeration and JSON. Callers can still explicitly clear the original context.
- */
-export declare function stripRuntimeContextExtensions(context: object): void;
-/**
- * Creates a typed accessor pair over the shared extension slot.
- *
- * The `id` must be globally unique (it is interned via `Symbol.for`); use a
- * package-prefixed name such as `@modern-js/plugin-tanstack:router-state`.
- */
-export declare function createRuntimeContextExtension<T>(id: string): RuntimeContextExtension<T>;

package/dist/types/core/context/helmetContext.d.ts

@@ -1,10 +0,0 @@
-/**
- * Fork-owned helmet state, stored via the runtime-context extension slot
- * instead of an ad-hoc `_helmetContext` field on `TInternalRuntimeContext`.
- */
-import type { HelmetServerState } from 'react-helmet-async';
-export interface HelmetContextSlot {
-    helmet?: HelmetServerState | null;
-}
-export declare function getHelmetContext(context: object): HelmetContextSlot | undefined;
-export declare function ensureHelmetContext(context: object): HelmetContextSlot;

package/dist/types/core/server/federatedCss.d.ts

@@ -1,5 +0,0 @@
-export declare const createFederatedCssLinks: (assets: string[] | undefined, options: {
-    template: string;
-    attributes?: Record<string, any>;
-    existingAssets?: Iterable<string>;
-}) => string;

package/dist/types/core/server/scriptOrder.d.ts

@@ -1,25 +0,0 @@
-import type { TInternalRuntimeContext } from '../context/index.js';
-type RouteAssetManifest = {
-    assets?: string[];
-};
-type RouteManifestLike = {
-    routeAssets?: Record<string, RouteAssetManifest | undefined>;
-};
-type ScriptChunkLike = {
-    filename?: string;
-    url?: string;
-};
-export declare function getMatchedRouteChunks<T>(runtimeContext: TInternalRuntimeContext, routeManifest: RouteManifestLike | undefined, routeAssetToChunk: (asset: string) => T): T[];
-export declare const orderHydrationScriptChunks: <T extends ScriptChunkLike>({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
-    asyncEntryChunks: T[];
-    collectedChunks: T[];
-    matchedRouteChunks: T[];
-    entryName: string;
-}) => T[];
-export declare function injectBeforeHydrationEntryScript(template: string, scripts: string, entryName?: string): string;
-export declare function replaceChunkJsPlaceholder(template: string, scripts: string, entryName?: string, placeholder?: string): string;
-export declare function createRouteHydrationScriptTags(runtimeContext: TInternalRuntimeContext, entryName: string, options?: {
-    nonce?: string;
-    template?: string;
-}): string;
-export {};

package/dist/types/module-federation/consume-surface.d.ts

@@ -1,104 +0,0 @@
-/**
- * G22 — mandatory degraded consumption API.
- *
- * CONTEXT.md (Degraded State): "consuming a surface obliges the consumer to
- * define a degraded state". This module turns that obligation into a
- * compile-level one: {@link SurfaceConsumerOptions.degraded} is a REQUIRED
- * field, so a call site that forgets its fallback does not type-check.
- *
- * The consumer wraps the loadRemote-ish flow (resolve a SurfaceRef through a
- * provider, then load the execution artifact from the resolved record) and
- * guarantees isolation: any discovery/load failure is caught, classified,
- * reported through the existing MF fallback telemetry, and handed to the
- * required degraded handler.
- *
- * Criticality (owner-default 5: unclassified consumption is `critical`). For a
- * `noncritical` consumption the degraded handler's result is returned and the
- * failure is swallowed, so one failing consumption can never propagate to a
- * sibling (CONTEXT.md: faults isolate at the vertical boundary). For a
- * `critical` consumption the degraded handler still runs — telemetry and
- * fallback-UI obligations hold — but the returned promise then REJECTS with the
- * typed failure so callers and rollout machinery observe it. Critical
- * 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';
-/** Where in the consumption lifecycle a failure was raised. */
-export type SurfaceConsumptionPhase = 'discovery' | 'load' | 'mount';
-/**
- * The typed failure surfaced to the degraded handler. Exactly one of
- * `discoveryError` (resolver returned a typed {@link DiscoveryError}) or
- * `error` (something threw) is populated for a given failure.
- */
-export type SurfaceConsumptionFailure = {
-    ref: ParsedSurfaceRef;
-    env: EnvironmentId;
-    phase: SurfaceConsumptionPhase;
-    classification: ModuleFederationFallbackClassification;
-    /** Present when discovery returned a typed error state. */
-    discoveryError?: DiscoveryError;
-    /** Present when a thrown error caused the failure. */
-    error?: unknown;
-    /** The resolved record, when discovery succeeded but load/mount failed. */
-    resolved?: ResolvedDeliveryUnit;
-    /** The fallback telemetry payload emitted for this failure. */
-    telemetry: ModuleFederationFallbackTelemetryPayload;
-};
-export type SurfaceLoadInput = {
-    resolved: ResolvedDeliveryUnit;
-    ref: ParsedSurfaceRef;
-    env: EnvironmentId;
-};
-export type SurfaceConsumerOptions<T> = {
-    /** The logical surface to consume (object or canonical string form). */
-    ref: ParsedSurfaceRef | string;
-    env: EnvironmentId;
-    /** The pluggable resolution seam (RESOLUTION-0001 §2.2). */
-    provider: SurfaceResolutionProvider;
-    /** Consumer app name, used for telemetry attribution. */
-    appName: string;
-    /**
-     * Loads the execution artifact from a resolved record — the loadRemote-ish
-     * flow. Receives the whole {@link ResolvedDeliveryUnit} so the adapter reads
-     * locations under one buildMarker (RESOLUTION-0001 §2.3).
-     */
-    load: (input: SurfaceLoadInput) => Promise<T> | T;
-    /**
-     * REQUIRED degraded handler (G22 compile-level obligation). There is no
-     * default and no way to opt out at the type level: omitting this field is a
-     * compile error. Return the value to serve while the surface is unavailable
-     * or incompatible.
-     */
-    degraded: (failure: SurfaceConsumptionFailure) => T | Promise<T>;
-    /**
-     * Consumption criticality (owner-default 5). Defaults to `'critical'` when
-     * omitted.
-     *
-     * - `'noncritical'`: the degraded handler's result is returned and the
-     *   failure is swallowed — the promise never rejects.
-     * - `'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
-     *   over silent degrade for critical surfaces during rollout windows.
-     */
-    classification?: 'critical' | 'noncritical';
-    /** Optional telemetry emission options (endpoint/auth/fetch overrides). */
-    telemetry?: ModuleFederationFallbackTelemetryEmitOptions;
-};
-/**
- * Consume one surface with a mandatory degraded fallback. On any discovery or
- * 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
- * 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>;
-/**
- * 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>;

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

@@ -1,61 +0,0 @@
-import type { ComponentType, ReactNode } from 'react';
-export declare const DISTRIBUTED_SSR_FRAGMENTS_LOCALS_KEY = "__modernDistributedSsrFragments";
-export declare const DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY = "__modernDistributedSsrFragmentRequest";
-export type DistributedSsrFragment = {
-    boundaryId: string;
-    buildMarker?: string;
-    digest?: string;
-    expose: string;
-    html: string;
-    remote: string;
-    status: 'ready';
-};
-export type DistributedSsrFragmentFailure = {
-    boundaryId: string;
-    expose: string;
-    reason: string;
-    remote: string;
-    status: 'degraded';
-};
-type DistributedSsrFragmentResult = DistributedSsrFragment | DistributedSsrFragmentFailure;
-export type DistributedSsrFragmentContext = {
-    fragments?: Record<string, DistributedSsrFragment | DistributedSsrFragmentFailure>;
-    required: true;
-    resolve?: (remote: string, expose: string, props: Record<string, unknown>) => DistributedSsrFragmentResult | PromiseLike<DistributedSsrFragmentResult>;
-};
-export type DistributedSsrBoundaryProps<Props extends object = Record<string, unknown>> = {
-    children: ReactNode;
-    expose: string;
-    fallback: ReactNode;
-    fragmentProps?: Props;
-    remote: string;
-};
-export type CreateDistributedSsrComponentOptions<Props extends object> = {
-    createComponent: () => ComponentType<Props>;
-    expose: string;
-    fallback: ReactNode;
-    remote: string;
-};
-export declare function distributedSsrFragmentKey(remote: string, expose: string): string;
-export declare function useDistributedSsrFragmentProps<Props extends object>({ boundaryId, expose, }: {
-    boundaryId: string;
-    expose: string;
-}): Props;
-/**
- * Keeps the browser on the native Module Federation component while allowing
- * servers that cannot execute remote code (notably workerd) to render a
- * trusted fragment produced by the remote Worker itself.
- *
- * Node SSR has no distributed-fragment context and therefore renders the
- * child normally, preserving Module Federation's in-process SSR path.
- */
-export declare function DistributedSsrBoundary<Props extends object = Record<string, unknown>>({ children, expose, fallback, fragmentProps, remote, }: DistributedSsrBoundaryProps<Props>): import("react").JSX.Element;
-/**
- * Defers creation of the native Module Federation component until React
- * actually renders that child. A workerd request with a verified distributed
- * fragment never constructs the native remote, so its module cannot perform
- * forbidden global-scope network I/O. Browser and Node rendering keep using
- * the native Module Federation component unchanged.
- */
-export declare function createDistributedSsrComponent<Props extends object>({ createComponent, expose, fallback, remote, }: CreateDistributedSsrComponentOptions<Props>): (props: Props) => import("react").JSX.Element;
-export {};

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

@@ -1,71 +0,0 @@
-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>;

package/dist/types/module-federation/last-known-good.d.ts

@@ -1,52 +0,0 @@
-import { type ResolvedDeliveryUnit, type SurfaceResolutionProvider } from './surface-resolution-types.js';
-export declare const LAST_KNOWN_GOOD_PROVIDER_NAME = "last-known-good";
-/** One cached complete record plus the time it was stored. */
-export type LkgRecord = {
-    resolved: ResolvedDeliveryUnit;
-    storedAt: number;
-    /**
-     * External-major selector the record was resolved against. Participates in
-     * lookup validation — a cached record is only served for a matching major —
-     * but never in the storage key, which is (unitId, env) so all surfaces of a
-     * unit share one atomically-swapped record.
-     */
-    major?: number;
-};
-/**
- * Pluggable storage hook. The default is an in-memory Map; callers may supply a
- * durable store (KV, disk, etc). Reads/writes may be async. A store only ever
- * receives whole records.
- */
-export type LkgStorage = {
-    read(key: string): (LkgRecord | undefined) | Promise<LkgRecord | undefined>;
-    write(key: string, record: LkgRecord): void | Promise<void>;
-};
-export type LkgFreshnessPolicy = {
-    /**
-     * Maximum age, in ms, a stored record may be served after a provider
-     * failure. When omitted, a served record never expires by age. A record
-     * older than this yields a typed `stale-record` discovery error.
-     */
-    maxStaleMs?: number;
-};
-export type LastKnownGoodOptions = {
-    /** The wrapped provider (env/static, Zephyr, or any other). */
-    provider: SurfaceResolutionProvider;
-    /** Pluggable storage; defaults to a process-local in-memory Map. */
-    storage?: LkgStorage;
-    freshness?: LkgFreshnessPolicy;
-    /** Clock injection for deterministic freshness tests. */
-    now?: () => number;
-};
-/** Default process-local in-memory storage. */
-export declare function createInMemoryLkgStorage(): LkgStorage;
-/**
- * Wrap a provider with a last-known-good cache. On success the whole record is
- * cached (atomic swap). On provider failure (typed discovery error or a thrown
- * error) the last complete record is served, marked degraded — unless it has
- * expired per {@link LkgFreshnessPolicy}, in which case a typed `stale-record`
- * error is returned. If there is no cached record, the original failure is
- * passed through (a thrown error becomes a `provider-unavailable` discovery
- * error).
- */
-export declare function createLastKnownGoodProvider(options: LastKnownGoodOptions): SurfaceResolutionProvider;

package/dist/types/module-federation/manifest-recovery-runtime-plugin.d.ts

@@ -1,25 +0,0 @@
-type ErrorLoadRemoteArgs = {
-    id?: string;
-    error?: unknown;
-    lifecycle?: string;
-};
-export type ModuleFederationManifestRecoveryPluginOptions = {
-    attempts?: number;
-    retryDelayMs?: number;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-    waitImpl?: (milliseconds: number) => Promise<void>;
-};
-/**
- * Gives server-side manifest loading a small, bounded recovery window.
- *
- * Returning `undefined` deliberately hands control back to Module Federation:
- * its runtime preserves the original typed RUNTIME-003 error and invalidates
- * the rejected manifest promise. Parsed manifests are returned without schema
- * interpretation so runtime-core remains the authority for RUNTIME-013.
- */
-export declare const createModuleFederationManifestRecoveryPlugin: (options?: ModuleFederationManifestRecoveryPluginOptions) => {
-    name: string;
-    errorLoadRemote(args: ErrorLoadRemoteArgs): Promise<unknown>;
-};
-export default createModuleFederationManifestRecoveryPlugin;