@bleedingdev/modern-js-runtime 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

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/types/boundary-debugger/index.d.ts

@@ -1,28 +0,0 @@
-import type { RuntimePlugin } from '../common';
-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';
-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';
-import { type DiscoveryError, type EnvironmentId, type ParsedSurfaceRef, type ResolvedDeliveryUnit, type SurfaceResolutionProvider } from './surface-resolution-types';
-/** 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';
-export * from './distributed-ssr';
-export { DISTRIBUTED_SSR_FRAGMENT_REQUEST_LOCALS_KEY, useDistributedSsrFragmentProps, } from './distributed-ssr';
-export * from './last-known-good';
-export * from './manifest-recovery-runtime-plugin';
-export * from './surface-resolution-types';
-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';
-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;

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

@@ -1,23 +0,0 @@
-/**
- * Surface-resolution types for the module-federation runtime.
- *
- * Thin re-export of the canonical module in `@modern-js/utils/universal`
- * (`packages/toolkit/utils/src/universal/surface-resolution/`,
- * RESOLUTION-0001). Kept as a file so existing `./surface-resolution-types`
- * imports stay stable. Only helpers the canonical module deliberately does not
- * ship (the (ref, env) cache key) live here, implemented against canonical
- * types.
- */
-import { type EnvironmentId, type ParsedSurfaceRef } from '@modern-js/utils/universal';
-export { type CompatibilityStatus, type CompatibilityVerdict, createDiscoveryError, type DiscoveryError, type DiscoveryErrorCode, type DiscoveryResult, type EnvironmentId, formatSurfaceRef, type ParsedSurfaceRef, parseSurfaceRef, type ResolvedDeliveryUnit, type ResolvedSurface, type ResolvedSurfaceKind, type ResolvedSurfaceLocation, type ResolvedSurfaceLocationPlatform, type SurfaceRefParseError, type SurfaceRefParseResult, type SurfaceResolutionProvider, validateSurfaceRef, } from '@modern-js/utils/universal';
-/** Stable cache/identity key for a (ref, env) pair. */
-export declare function surfaceResolutionKey(ref: ParsedSurfaceRef, env: EnvironmentId): string;
-/**
- * Stable cache key for a (deliveryUnit, env) pair — ONE record per unit per
- * env (ADR-0019 atomicity). All surfaces of a unit share this key so a refresh
- * replaces the whole unit snapshot atomically for every surface, and two
- * surfaces of the same unit can never be served from different cached
- * snapshots. The ref's external-major participates in lookup validation (see
- * the LKG provider), not in this key.
- */
-export declare function deliveryUnitResolutionKey(unitId: string, env: EnvironmentId): string;

package/dist/types/router/runtime/lifecycle.d.ts

@@ -1,27 +0,0 @@
-import type { RouteObject } from '@modern-js/runtime-utils/router';
-import type { TInternalRuntimeContext } from '../../core/context/runtime';
-import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterRouteMatchSnapshot, RouterServerPrepareResult } from './types';
-export declare function getRouterRuntimeState(runtimeContext: object): InternalRouterRuntimeState | undefined;
-export declare function getRouterServerSnapshot(runtimeContext: object): InternalRouterServerSnapshot | undefined;
-export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';
-export type RouterLifecycleContext = {
-    framework: RouterFramework;
-    phase: RouterLifecyclePhase;
-    routes: RouteObject[];
-    runtimeContext: TInternalRuntimeContext;
-    basename?: string;
-    hydrationData?: unknown;
-    router?: unknown;
-    matches?: RouterRouteMatchSnapshot[];
-    cleanup?: () => void | Promise<void>;
-    serverSnapshot?: InternalRouterServerSnapshot;
-};
-type RouterSnapshotLike = Partial<InternalRouterServerSnapshot>;
-export declare function createRouterServerSnapshot(state: RouterSnapshotLike): InternalRouterServerSnapshot;
-export declare function createRouterRuntimeState(state: InternalRouterRuntimeState): InternalRouterRuntimeState;
-export declare function applyRouterRuntimeState(runtimeContext: TInternalRuntimeContext, state: InternalRouterRuntimeState): TInternalRuntimeContext;
-export declare function applyRouterServerPrepareResult(runtimeContext: TInternalRuntimeContext, result: RouterServerPrepareResult): TInternalRuntimeContext;
-export declare function getRouterHydrationScripts(runtimeContext: TInternalRuntimeContext): string[];
-export declare function getRouterMatchedRouteIds(runtimeContext: TInternalRuntimeContext): string[] | undefined;
-export declare function cleanupRouterRuntimeState(runtimeContext: TInternalRuntimeContext): Promise<void>;
-export {};

package/dist/types/router/runtime/provider.d.ts

@@ -1,78 +0,0 @@
-/**
- * Fork-owned router-provider registry.
- *
- * `runtime.router.framework` selects the router implementation used by the
- * built-in router runtime plugin (`@modern-js/runtime/router/internal`).
- * Instead of hardcoding every implementation there, providers register
- * themselves here:
- *
- * - `react-router` registers itself as the default provider when the
- *   built-in router plugin module is loaded.
- * - `@modern-js/plugin-tanstack` registers the `tanstack` provider when its
- *   runtime entry is imported.
- */
-import type { RuntimePlugin } from '../../common';
-import type { RouterExtendsHooks } from './hooks';
-import type { RouterConfig } from './types';
-/**
- * The single declaration source for the router hook registry. Every router
- * provider (built-in react-router, @modern-js/plugin-tanstack, ...) and the
- * framework-resolving wrapper plugin register exactly these instances, so the
- * hook set is defined once and providers cannot drift apart.
- */
-export declare const routerProviderRegistryHooks: RouterExtendsHooks;
-export type RouterProviderPlugin = RuntimePlugin<{
-    extendHooks: RouterExtendsHooks;
-}>;
-/**
- * Guard for the wrapper plugin (`router/internal`): a resolved provider is
- * only invoked through `setup`, so registry hooks outside the canonical
- * router hook contract cannot be registered for it. Returns the offending
- * hook names and warns once so they are surfaced instead of silently dropped.
- */
-export declare function reportUnsupportedProviderRegistryHooks(providerPlugin: {
-    name?: string;
-    registryHooks?: Record<string, unknown>;
-}): string[];
-export type RouterProviderFactory = (userConfig: Partial<RouterConfig>) => RouterProviderPlugin;
-export type RouterProviderRegistration = {
-    name: string;
-    factory: RouterProviderFactory;
-    isDefault?: boolean;
-};
-/**
- * App-owned provider catalog. Provider factories close over their module graph,
- * so they must be resolved from the runtime wrapper that owns the app instead
- * of from a page-global first-registration winner.
- */
-export type RouterProviderRealm = Readonly<{
-    defaultProvider?: string;
-    get: (name: string) => RouterProviderFactory | undefined;
-    names: () => readonly string[];
-}>;
-export declare function createRouterProviderRealm(registrations: readonly RouterProviderRegistration[]): RouterProviderRealm;
-export declare function registerRouterProvider(name: string, factory: RouterProviderFactory, options?: {
-    isDefault?: boolean;
-}): void;
-export declare function resolveRouterProvider(framework?: RouterConfig['framework'], options?: {
-    /**
-     * Provider factories owned by the resolving app/runtime wrapper. A realm
-     * is the exclusive provider source when supplied because its factories
-     * close over the correct app module graph.
-     */
-    realm?: RouterProviderRealm;
-    /**
-     * Legacy single-provider override retained for published wrappers. New
-     * integrations should pass an app-owned `realm`, which supports every
-     * provider rather than only the default.
-     */
-    localDefault?: {
-        name: string;
-        factory: RouterProviderFactory;
-    };
-}): RouterProviderFactory;
-/**
- * Test-only escape hatch: compatibility registries live on `globalThis`, so
- * unit tests need a way to restore a pristine state between cases.
- */
-export declare function unsafe_resetRouterProvidersForTesting(): void;