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

package/dist/types/runtime/data-platform/index.d.ts

@@ -1,191 +1,7 @@
-export type DataRequestMode = 'cache-first' | 'stale-while-revalidate' | 'network-only';
-export type DataMutationMode = 'optimistic' | 'pessimistic' | 'fire-and-forget';
-export type SelectionPlan = {
-    [field: string]: true | SelectionPlan;
-};
-export interface OperationDescriptor {
-    appNamespace: string;
-    apiId: string;
-    group: string;
-    endpoint: string;
-    schemaHash?: string;
-    version?: number;
-}
-export interface CacheScope {
-    appNamespace: string;
-    origin: string;
-    tenantId?: string;
-    userId?: string;
-    sessionId?: string;
-}
-export interface TraceContext {
-    traceId: string;
-    spanId: string;
-    sampled: boolean;
-    parentSpanId?: string;
-}
-export interface RequestEnvelope<Input = unknown> {
-    protocolVersion: 1;
-    operationId: string;
-    appNamespace: string;
-    origin: string;
-    requestMode: DataRequestMode;
-    mutationMode?: DataMutationMode;
-    scopeKey: string;
-    input: Input;
-    inputHash: string;
-    selectionPlan?: SelectionPlan;
-    selectionHash?: string;
-    traceparent?: string;
-    timestamp: number;
-}
-export interface HydrationEnvelope<Payload = unknown> {
-    protocolVersion: 1;
-    runtimeVersion: string;
-    appNamespace: string;
-    origin: string;
-    createdAt: number;
-    payload: Payload;
-    checksum: string;
-}
-export interface InvalidationEvent {
-    sourceNamespace: string;
-    sourceOperationId: string;
-    scopeKey: string;
-    targetNamespaces?: string[];
-    targetOperationIds?: string[];
-}
-export interface InvalidationSubscriber {
-    namespace: string;
-    operationIds?: string[];
-    scopeKey?: string;
-    acceptCrossNamespace?: boolean;
-}
-export interface DataBatchRequestItem {
-    id: string;
-    path: string;
-    method: string;
-    headers?: Record<string, string>;
-    body?: string;
-}
-export interface DataBatchRequestPayload {
-    protocolVersion: 1;
-    batchId: string;
-    sentAt: number;
-    items: DataBatchRequestItem[];
-}
-export interface DataBatchResponseItem {
-    id: string;
-    status: number;
-    headers?: Record<string, string>;
-    body?: string;
-}
-export interface DataBatchResponsePayload {
-    protocolVersion: 1;
-    batchId: string;
-    receivedAt: number;
-    items: DataBatchResponseItem[];
-}
-export interface DataBatchTransportEvent {
-    type: 'enqueue' | 'flush' | 'fallback' | 'disable';
-    endpoint: string;
-    batchId?: string;
-    size?: number;
-    reason?: string;
-}
-export type DataBatchTransportTelemetryAttributes = Record<string, string | number | boolean>;
-export interface DataBatchTransportOptions {
-    endpoint?: string;
-    fetch?: (input: DataTransportRequestInfo, init?: RequestInit) => Promise<Response>;
-    flushIntervalMs?: number;
-    maxBatchSize?: number;
-    maxBatchBytes?: number;
-    requestTimeoutMs?: number;
-    allowedMethods?: string[];
-    onEvent?: (event: DataBatchTransportEvent) => void;
-}
-export declare const DATA_BATCH_TRANSPORT_OTEL_EVENT = "modernjs.data.batch";
-export declare function createDataBatchTransportTelemetryAttributes(event: DataBatchTransportEvent): DataBatchTransportTelemetryAttributes;
-export declare function emitDataBatchTransportEvent(onEvent: ((event: DataBatchTransportEvent) => void) | undefined, event: DataBatchTransportEvent): void;
-export interface SelectionPlanValidationOptions {
-    maxDepth?: number;
-    maxFields?: number;
-    allowedLeafPaths?: ReadonlyArray<string>;
-}
-export interface SelectionPlanValidationResult {
-    ok: boolean;
-    errors: string[];
-    stats: {
-        maxDepth: number;
-        fieldCount: number;
-    };
-}
-export interface RequestEnvelopeValidationOptions {
-    expectedProtocolVersion?: number;
-    expectedNamespace?: string;
-    expectedOrigin?: string;
-    requireTraceContext?: boolean;
-}
-export interface HydrationEnvelopeValidationOptions {
-    expectedProtocolVersion?: number;
-    expectedNamespace?: string;
-    expectedOrigin?: string;
-    expectedRuntimeVersion?: string;
-}
-export declare const DEFAULT_DATA_ENVELOPE_HEADER = "x-modernjs-data-envelope";
-export declare const DEFAULT_DATA_BATCH_ENDPOINT = "/_data/batch";
-export declare const DEFAULT_DATA_BATCH_HEADER = "x-modernjs-data-batch";
-type DataTransportRequestInfo = string | URL | Request;
-export declare function stableStringify(value: unknown): string;
-export declare function encodeRequestEnvelopeHeader(envelope: RequestEnvelope): string;
-export declare function decodeRequestEnvelopeHeader(value: string): RequestEnvelope | null;
-export declare function normalizeOrigin(origin: string): string;
-export declare function createOperationId(input: OperationDescriptor): string;
-export declare function buildScopeKey(scope: CacheScope): string;
-export declare function buildQueryKey(input: {
-    operationId: string;
-    scopeKey: string;
-    requestMode?: DataRequestMode;
-    requestInput?: unknown;
-    selectionPlan?: SelectionPlan;
-}): string;
-export declare function parseTraceparentHeader(header: string): TraceContext | null;
-export declare function formatTraceparentHeader(trace: TraceContext): string;
-export declare function deriveChildTraceContext(parent: TraceContext, childSpanId: string): TraceContext;
-export declare function validateSelectionPlan(plan: SelectionPlan, options?: SelectionPlanValidationOptions): SelectionPlanValidationResult;
-export declare function createRequestEnvelope<Input>(input: {
-    operation: OperationDescriptor;
-    scope: CacheScope;
-    requestInput: Input;
-    selectionPlan?: SelectionPlan;
-    requestMode?: DataRequestMode;
-    mutationMode?: DataMutationMode;
-    traceContext?: TraceContext;
-    requireTraceContext?: boolean;
-    timestamp?: number;
-    protocolVersion?: 1;
-}): RequestEnvelope<Input>;
-export declare function validateRequestEnvelope(envelope: RequestEnvelope, options?: RequestEnvelopeValidationOptions): {
-    ok: boolean;
-    errors: string[];
-};
-export declare function createHydrationEnvelope<Payload>(input: {
-    runtimeVersion: string;
-    scope: Pick<CacheScope, 'appNamespace' | 'origin'>;
-    payload: Payload;
-    createdAt?: number;
-    protocolVersion?: 1;
-}): HydrationEnvelope<Payload>;
-export declare function validateHydrationEnvelope(envelope: HydrationEnvelope, options?: HydrationEnvelopeValidationOptions): {
-    ok: boolean;
-    errors: string[];
-};
-export declare function createInvalidationEvent(input: {
-    sourceOperation: OperationDescriptor;
-    sourceScope: CacheScope;
-    targetNamespaces?: string[];
-    targetOperations?: OperationDescriptor[];
-}): InvalidationEvent;
-export declare function shouldApplyInvalidation(event: InvalidationEvent, subscriber: InvalidationSubscriber): boolean;
-export declare function createDataBatchTransport(options?: DataBatchTransportOptions): (input: DataTransportRequestInfo, init?: RequestInit) => Promise<any>;
-export {};
+export { createDataBatchTransport, createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch-transport';
+export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, normalizeOrigin, stableStringify, } from './codec';
+export { createInvalidationEvent, shouldApplyInvalidation, } from './invalidation';
+export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader, } from './trace';
+export type { CacheScope, DataBatchRequestItem, DataBatchRequestPayload, DataBatchResponseItem, DataBatchResponsePayload, DataBatchTransportEvent, DataBatchTransportOptions, DataBatchTransportTelemetryAttributes, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, InvalidationEvent, InvalidationSubscriber, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext, } from './types';
+export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, } from './types';
+export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan, } from './validation';

package/dist/types/runtime/data-platform/invalidation.d.ts

@@ -0,0 +1,8 @@
+import type { CacheScope, InvalidationEvent, InvalidationSubscriber, OperationDescriptor } from './types';
+export declare function createInvalidationEvent(input: {
+    sourceOperation: OperationDescriptor;
+    sourceScope: CacheScope;
+    targetNamespaces?: string[];
+    targetOperations?: OperationDescriptor[];
+}): InvalidationEvent;
+export declare function shouldApplyInvalidation(event: InvalidationEvent, subscriber: InvalidationSubscriber): boolean;

package/dist/types/runtime/data-platform/trace.d.ts

@@ -0,0 +1,4 @@
+import type { TraceContext } from './types';
+export declare function parseTraceparentHeader(header: string): TraceContext | null;
+export declare function formatTraceparentHeader(trace: TraceContext): string;
+export declare function deriveChildTraceContext(parent: TraceContext, childSpanId: string): TraceContext;

package/dist/types/runtime/data-platform/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Data-platform envelope (`x-modernjs-data-envelope`): the TRANSPORT/CACHE
+ * contract of the effect lane — protocol versioning, cache scope keys,
+ * selection plans, batching and hydration checksums.
+ *
+ * Boundary note (one envelope system per concern): cross-project
+ * AUTHORIZATION is the bff-core policy's job (`x-modernjs-bff-envelope` +
+ * operation contracts, evaluated server-side in both the hono and effect
+ * lanes). Nothing in this module is a trust boundary; treat every value
+ * here as client-asserted cache metadata.
+ */
+export type DataRequestMode = 'cache-first' | 'stale-while-revalidate' | 'network-only';
+export type DataMutationMode = 'optimistic' | 'pessimistic' | 'fire-and-forget';
+export type SelectionPlan = {
+    [field: string]: true | SelectionPlan;
+};
+export interface OperationDescriptor {
+    appNamespace: string;
+    apiId: string;
+    group: string;
+    endpoint: string;
+    schemaHash?: string;
+    version?: number;
+}
+export interface CacheScope {
+    appNamespace: string;
+    origin: string;
+    tenantId?: string;
+    userId?: string;
+    sessionId?: string;
+}
+export interface TraceContext {
+    traceId: string;
+    spanId: string;
+    sampled: boolean;
+    parentSpanId?: string;
+}
+export interface RequestEnvelope<Input = unknown> {
+    protocolVersion: 1;
+    operationId: string;
+    appNamespace: string;
+    origin: string;
+    requestMode: DataRequestMode;
+    mutationMode?: DataMutationMode;
+    scopeKey: string;
+    input: Input;
+    inputHash: string;
+    selectionPlan?: SelectionPlan;
+    selectionHash?: string;
+    traceparent?: string;
+    timestamp: number;
+}
+export interface HydrationEnvelope<Payload = unknown> {
+    protocolVersion: 1;
+    runtimeVersion: string;
+    appNamespace: string;
+    origin: string;
+    createdAt: number;
+    payload: Payload;
+    checksum: string;
+}
+export interface InvalidationEvent {
+    sourceNamespace: string;
+    sourceOperationId: string;
+    scopeKey: string;
+    targetNamespaces?: string[];
+    targetOperationIds?: string[];
+}
+export interface InvalidationSubscriber {
+    namespace: string;
+    operationIds?: string[];
+    scopeKey?: string;
+    acceptCrossNamespace?: boolean;
+}
+export interface DataBatchRequestItem {
+    id: string;
+    path: string;
+    method: string;
+    headers?: Record<string, string>;
+    body?: string;
+}
+export interface DataBatchRequestPayload {
+    protocolVersion: 1;
+    batchId: string;
+    sentAt: number;
+    items: DataBatchRequestItem[];
+}
+export interface DataBatchResponseItem {
+    id: string;
+    status: number;
+    headers?: Record<string, string>;
+    body?: string;
+}
+export interface DataBatchResponsePayload {
+    protocolVersion: 1;
+    batchId: string;
+    receivedAt: number;
+    items: DataBatchResponseItem[];
+}
+export interface DataBatchTransportEvent {
+    type: 'enqueue' | 'flush' | 'fallback' | 'disable';
+    endpoint: string;
+    batchId?: string;
+    size?: number;
+    reason?: string;
+}
+export type DataBatchTransportTelemetryAttributes = Record<string, string | number | boolean>;
+export interface DataBatchTransportOptions {
+    endpoint?: string;
+    fetch?: (input: DataTransportRequestInfo, init?: RequestInit) => Promise<Response>;
+    flushIntervalMs?: number;
+    maxBatchSize?: number;
+    maxBatchBytes?: number;
+    requestTimeoutMs?: number;
+    allowedMethods?: string[];
+    onEvent?: (event: DataBatchTransportEvent) => void;
+}
+export interface SelectionPlanValidationOptions {
+    maxDepth?: number;
+    maxFields?: number;
+    allowedLeafPaths?: ReadonlyArray<string>;
+}
+export interface SelectionPlanValidationResult {
+    ok: boolean;
+    errors: string[];
+    stats: {
+        maxDepth: number;
+        fieldCount: number;
+    };
+}
+export interface RequestEnvelopeValidationOptions {
+    expectedProtocolVersion?: number;
+    expectedNamespace?: string;
+    expectedOrigin?: string;
+    requireTraceContext?: boolean;
+}
+export interface HydrationEnvelopeValidationOptions {
+    expectedProtocolVersion?: number;
+    expectedNamespace?: string;
+    expectedOrigin?: string;
+    expectedRuntimeVersion?: string;
+}
+export declare const DEFAULT_DATA_ENVELOPE_HEADER = "x-modernjs-data-envelope";
+export declare const DEFAULT_DATA_BATCH_ENDPOINT = "/_data/batch";
+export declare const DEFAULT_DATA_BATCH_HEADER = "x-modernjs-data-batch";
+export type DataTransportRequestInfo = string | URL | Request;

package/dist/types/runtime/data-platform/validation.d.ts

@@ -0,0 +1,29 @@
+import type { CacheScope, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext } from './types';
+export declare function validateSelectionPlan(plan: SelectionPlan, options?: SelectionPlanValidationOptions): SelectionPlanValidationResult;
+export declare function createRequestEnvelope<Input>(input: {
+    operation: OperationDescriptor;
+    scope: CacheScope;
+    requestInput: Input;
+    selectionPlan?: SelectionPlan;
+    requestMode?: DataRequestMode;
+    mutationMode?: DataMutationMode;
+    traceContext?: TraceContext;
+    requireTraceContext?: boolean;
+    timestamp?: number;
+    protocolVersion?: 1;
+}): RequestEnvelope<Input>;
+export declare function validateRequestEnvelope(envelope: RequestEnvelope, options?: RequestEnvelopeValidationOptions): {
+    ok: boolean;
+    errors: string[];
+};
+export declare function createHydrationEnvelope<Payload>(input: {
+    runtimeVersion: string;
+    scope: Pick<CacheScope, 'appNamespace' | 'origin'>;
+    payload: Payload;
+    createdAt?: number;
+    protocolVersion?: 1;
+}): HydrationEnvelope<Payload>;
+export declare function validateHydrationEnvelope(envelope: HydrationEnvelope, options?: HydrationEnvelopeValidationOptions): {
+    ok: boolean;
+    errors: string[];
+};

package/dist/types/runtime/effect/adapter/constants.d.ts

@@ -0,0 +1 @@
+export declare const before: string[];

package/dist/types/runtime/effect/adapter/cross-project-policy.d.ts

@@ -0,0 +1,4 @@
+import type { ServerPluginAPI } from '@modern-js/server-core';
+import { type ResolvedCrossProjectPolicy } from '../../../utils/crossProjectServerPolicy';
+import type { EffectApiModule } from '../module';
+export declare function resolveEffectAdapterCrossProjectPolicy(api: ServerPluginAPI, prefix: string, mod: EffectApiModule | null): Promise<ResolvedCrossProjectPolicy>;

package/dist/types/runtime/effect/adapter/entry.d.ts

@@ -0,0 +1,2 @@
+import type { ServerPluginAPI } from '@modern-js/server-core';
+export declare function resolveEffectAdapterEntryFile(api: ServerPluginAPI): string | undefined;

package/dist/types/runtime/effect/adapter/error-response.d.ts

@@ -0,0 +1,2 @@
+import type { Context, ServerPluginAPI } from '@modern-js/server-core';
+export declare function createEffectAdapterRuntimeErrorResponse(api: ServerPluginAPI, error: unknown, c: Context): Promise<Response>;

package/dist/types/runtime/effect/adapter/handler.d.ts

@@ -0,0 +1,7 @@
+import type { ServerPluginAPI } from '@modern-js/server-core';
+import { type ResolvedCrossProjectPolicy } from '../../../utils/crossProjectServerPolicy';
+import { type EffectApiModule } from '../module';
+export declare function loadEffectAdapterHandlerFromModule(api: ServerPluginAPI, mod: EffectApiModule, crossProjectPolicy: ResolvedCrossProjectPolicy | undefined): Promise<{
+    handler: import("../module").EffectBffRequestHandler;
+    dispose?: () => Promise<void>;
+} | null>;

package/dist/types/runtime/effect/adapter.d.ts

@@ -1,14 +1,14 @@
 import type { ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
-import { type ResolvedCrossProjectPolicy } from '../../utils/crossProjectServerPolicy';
+import type { ResolvedCrossProjectPolicy } from '../../utils/crossProjectServerPolicy';
 interface MiddlewareOptions {
     prefix: string;
     enableHandleWeb?: boolean;
 }
 export declare class EffectAdapter {
-    api: ServerPluginAPI;
+    private api;
     isEffect: boolean;
-    effectMiddleware: ServerMiddleware | null;
-    crossProjectPolicy: ResolvedCrossProjectPolicy | undefined;
+    effectMiddleware?: ServerMiddleware;
+    crossProjectPolicy?: ResolvedCrossProjectPolicy;
     private handler;
     private dispose;
     private prefix;
@@ -16,16 +16,7 @@ export declare class EffectAdapter {
     registerMiddleware: (options: MiddlewareOptions) => Promise<void>;
     onApiHandlersUpdated: () => Promise<void>;
     private resolveEntryFile;
-    /**
-     * Resolves the cross-project policy from the reflected HttpApi endpoints so
-     * the expected operation contracts match the hashes the client generators
-     * stamp into generated SDKs.
-     */
-    private refreshCrossProjectPolicy;
-    private loadEffectHandlerFromModule;
     private reloadHandler;
     private disposeCurrentHandler;
-    private handleRuntimeError;
-    private ensureJsonContext;
 }
 export {};

package/dist/types/runtime/effect/backend-federation/entry.d.ts

@@ -0,0 +1,2 @@
+import type { BackendFederationRemote, BackendFederationRuntimeOptions } from './types';
+export declare function loadBackendFederationExpose(remote: BackendFederationRemote, expose: string, options: BackendFederationRuntimeOptions): Promise<unknown>;

package/dist/types/runtime/effect/backend-federation/identity.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Mandatory delivery-unit identity for public backend federation loads
+ * (MV-G23, ADR-0019 / RESOLUTION-0001 §2.3): consumers pass the record's
+ * `unitId` + `buildMarker` through to identity validation.
+ */
+export type BackendFederationExpectedIdentity = {
+    unitId: string;
+    buildMarker: string;
+};
+export type BackendFederationIdentityIssue = {
+    path: string;
+    message: string;
+};
+/**
+ * Shared expected-identity validation for loaded backend federation modules.
+ * Compares the expose's `backendFederationContract.compatibility` identity
+ * (`unitId`, `build`) against the consumer's expected delivery-unit identity.
+ * Missing identity metadata is an error: with an expectation present there is
+ * no legacy escape hatch.
+ */
+export declare function validateExpectedBackendFederationIdentity(loaded: unknown, expected: BackendFederationExpectedIdentity, options?: {
+    /**
+     * Tolerate exposes that declare no identity metadata (legacy modules).
+     * Mismatching declared values still fail. Used by the manifest adapter,
+     * whose manifest-side identity is already validated against `expected`;
+     * the raw identity-aware loader is strict.
+     */
+    allowMissingIdentityMetadata?: boolean;
+}): BackendFederationIdentityIssue[];
+export declare function formatBackendFederationIdentityIssues(issues: BackendFederationIdentityIssue[]): string;

package/dist/types/runtime/effect/backend-federation/load.d.ts

@@ -0,0 +1,13 @@
+import type { BackendFederatedEffectApiModule, BackendFederationIdentityLoadOptions, BackendFederationLoadOptions } from './types';
+/**
+ * Load a federated Effect API with mandatory delivery-unit identity
+ * validation (MV-G23): the loaded expose's compatibility metadata must match
+ * `expected.unitId` + `expected.buildMarker`.
+ */
+export declare function loadBackendFederatedEffectApi(options: BackendFederationIdentityLoadOptions): Promise<BackendFederatedEffectApiModule>;
+/**
+ * @deprecated Pass `expected` (delivery-unit `unitId` + `buildMarker`).
+ * Loads without an expected identity cannot be validated against a resolved
+ * delivery-unit record and emit a runtime warning.
+ */
+export declare function loadBackendFederatedEffectApi(options: BackendFederationLoadOptions): Promise<BackendFederatedEffectApiModule>;

package/dist/types/runtime/effect/backend-federation/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import type { BackendFederationLoadEntryPluginOptions } from './types';
+export declare function createBackendFederationLoadEntryPlugin(options: BackendFederationLoadEntryPluginOptions): ModuleFederationRuntimePlugin;

package/dist/types/runtime/effect/backend-federation/remotes.d.ts

@@ -0,0 +1,2 @@
+import type { BackendFederationRuntimeOptions } from './types';
+export declare function collectRemotes(options: BackendFederationRuntimeOptions): import("./types").BackendFederationRemote[];

package/dist/types/runtime/effect/backend-federation/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleFederation } from '@module-federation/runtime';
+import type { BackendFederationRuntimeOptions } from './types';
+export declare function createBackendFederationRuntime(options: BackendFederationRuntimeOptions): ModuleFederation;

package/dist/types/runtime/effect/backend-federation/types.d.ts

@@ -0,0 +1,73 @@
+import type { BACKEND_FEDERATION_EFFECT_EXPOSE } from '@modern-js/utils/universal';
+import type { ModuleFederation, ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import type { EffectApiModule } from '../module';
+import type { BackendFederationExpectedIdentity } from './identity';
+export type BackendFederationRemote = {
+    name: string;
+    entry: string;
+    type?: 'commonjs-module' | 'module' | string;
+    entryGlobalName?: string;
+    shareScope?: string | string[];
+    expose?: typeof BACKEND_FEDERATION_EFFECT_EXPOSE;
+};
+export type BackendFederationRuntimeOptions = {
+    hostName: string;
+    remote?: BackendFederationRemote;
+    remotes?: BackendFederationRemote[];
+    plugins?: ModuleFederationRuntimePlugin[];
+};
+export type BackendFederationEntryExports = {
+    get: (id: string) => (() => Promise<unknown> | unknown) | Promise<() => Promise<unknown> | unknown>;
+    init?: (...args: unknown[]) => void | Promise<void>;
+};
+export type BackendFederatedEffectApiModule = EffectApiModule & {
+    backendFederationContract?: {
+        compatibility?: {
+            build?: unknown;
+            contractVersion?: unknown;
+            nodeAdapterVersion?: unknown;
+            packageName?: unknown;
+            /**
+             * ADR-0019 delivery-unit identity root, generator-emitted alongside
+             * manifest's `versionBoundary.deliveryUnit`. Additive/optional.
+             */
+            unitId?: unknown;
+            /** ADR-0019 delivery-unit source revision. Additive/optional. */
+            sourceRevision?: unknown;
+        };
+        name?: unknown;
+        role?: unknown;
+        runtimeFramework?: unknown;
+        strictEffectApproach?: unknown;
+    };
+    contract?: unknown;
+    operationContexts?: unknown;
+    runtime?: unknown;
+};
+export type BackendFederationLoadEntryPluginOptions = {
+    resolveEntry: (remote: BackendFederationRemote) => BackendFederationEntryExports | undefined | Promise<BackendFederationEntryExports | undefined>;
+};
+export type BackendFederationLoadOptions = BackendFederationRuntimeOptions & {
+    runtime?: ModuleFederation;
+    remoteName?: string;
+    expose?: string;
+};
+/**
+ * Identity-aware public load options (MV-G23): the expected delivery-unit
+ * `unitId` + `buildMarker` are mandatory and validated against the loaded
+ * expose's compatibility metadata.
+ */
+export type BackendFederationIdentityLoadOptions = BackendFederationLoadOptions & {
+    expected: BackendFederationExpectedIdentity;
+    /**
+     * Tolerate legacy exposes without identity metadata (mismatching declared
+     * values still fail). Prefer leaving this unset: identity-less exposes
+     * cannot be validated against a resolved delivery-unit record.
+     */
+    allowMissingIdentityMetadata?: boolean;
+};
+export type BackendFederationLoadEntryPlugin = ModuleFederationRuntimePlugin & {
+    loadEntry?: (args: {
+        remoteInfo: BackendFederationRemote;
+    }) => BackendFederationEntryExports | undefined | Promise<BackendFederationEntryExports | undefined>;
+};

package/dist/types/runtime/effect/backend-federation/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeExpose(expose: string): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/types/runtime/effect/backend-federation-manifest/errors.d.ts

@@ -0,0 +1,11 @@
+export type BackendFederationManifestAdapterErrorCode = 'manifest_unavailable' | 'manifest_invalid' | 'remote_unavailable' | 'strict_effect_required' | 'timeout' | 'version_mismatch';
+export declare const BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT: 'modernjs:microvertical-server-fallback';
+export declare class BackendFederationManifestAdapterError extends Error {
+    code: BackendFederationManifestAdapterErrorCode;
+    readonly failureEvent: "modernjs:microvertical-server-fallback";
+    details?: Record<string, unknown>;
+    constructor(code: BackendFederationManifestAdapterErrorCode, message: string, cause?: unknown, details?: Record<string, unknown>);
+}
+export declare function assertManifestAdapter(condition: unknown, code: BackendFederationManifestAdapterErrorCode, message: string): asserts condition;
+export declare function assertVersionValue(actual: string | undefined, expected: string | undefined, label: string, details?: Record<string, unknown>): void;
+export declare function assertConsistentValue(left: string | undefined, right: string | undefined, label: string, details?: Record<string, unknown>): void;

package/dist/types/runtime/effect/backend-federation-manifest/index.d.ts

@@ -0,0 +1,6 @@
+export type { BackendFederationManifestAdapterErrorCode } from './errors';
+export { BACKEND_FEDERATION_MANIFEST_ADAPTER_FAILURE_EVENT, BackendFederationManifestAdapterError, } from './errors';
+export { loadBackendFederatedEffectApiFromManifest } from './load';
+export { loadBackendFederationManifest } from './reference';
+export { resolveBackendFederationRemoteFromManifest } from './remote';
+export type { BackendFederationManifest, BackendFederationManifestAdapterFallback, BackendFederationManifestAdapterOptions, BackendFederationManifestFetchResponse, BackendFederationVersionBoundaryExpectation, } from './types';

package/dist/types/runtime/effect/backend-federation-manifest/load.d.ts

@@ -0,0 +1,3 @@
+import { type BackendFederatedEffectApiModule } from '../backend-federation';
+import type { BackendFederationManifestAdapterOptions } from './types';
+export declare function loadBackendFederatedEffectApiFromManifest(options: BackendFederationManifestAdapterOptions): Promise<BackendFederatedEffectApiModule>;

package/dist/types/runtime/effect/backend-federation-manifest/metadata.d.ts

@@ -0,0 +1,18 @@
+import type { BackendFederationManifest } from './types';
+export declare function stringValue(value: unknown): string | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function recordField(value: Record<string, unknown> | undefined, field: string): Record<string, unknown> | undefined;
+export declare function resolveRemoteEntryFromMetadata(manifest: BackendFederationManifest): string | undefined;
+export declare function backendFederationMetadata(manifest: BackendFederationManifest): Record<string, unknown> | undefined;
+export declare function versionBoundaryMetadata(manifest: BackendFederationManifest): Record<string, unknown> | undefined;
+export declare function deliveryUnitMetadata(record: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+/**
+ * Resolves the delivery-unit identity root for a manifest (ADR-0019 §3):
+ * prefers `versionBoundary.deliveryUnit`, falls back to the top-level
+ * `backendFederation.deliveryUnit` record. Both are additive/optional so
+ * legacy manifests without delivery-unit metadata continue to validate.
+ */
+export declare function manifestDeliveryUnit(backendFederation: Record<string, unknown> | undefined, boundary: Record<string, unknown> | undefined): {
+    boundary: Record<string, unknown> | undefined;
+    top: Record<string, unknown> | undefined;
+};

package/dist/types/runtime/effect/backend-federation-manifest/reference.d.ts

@@ -0,0 +1,4 @@
+import type { BackendFederationManifest, BackendFederationManifestAdapterOptions } from './types';
+export declare function resolveBackendFederationManifestReference(options: Pick<BackendFederationManifestAdapterOptions, 'env' | 'manifestEnv' | 'manifestPath' | 'manifestUrl'>): string | undefined;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number | undefined, label: string): Promise<T>;
+export declare function loadBackendFederationManifest(options: Pick<BackendFederationManifestAdapterOptions, 'allowLegacyManifest' | 'env' | 'expected' | 'fetch' | 'manifest' | 'manifestEnv' | 'manifestPath' | 'manifestUrl' | 'timeoutMs'>): Promise<BackendFederationManifest>;

package/dist/types/runtime/effect/backend-federation-manifest/remote.d.ts

@@ -0,0 +1,3 @@
+import { type BackendFederationRemote } from '../backend-federation';
+import type { BackendFederationManifest } from './types';
+export declare function resolveBackendFederationRemoteFromManifest(manifest: BackendFederationManifest, remoteOverride?: Partial<BackendFederationRemote>): BackendFederationRemote;