@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

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 | false | 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,4 @@
+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<import("../module").LoadedEffectBffHandler | 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/load.d.ts

@@ -0,0 +1,2 @@
+import type { BackendFederatedEffectApiModule, BackendFederationLoadOptions } from './types';
+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,58 @@
+import type { BACKEND_FEDERATION_EFFECT_EXPOSE } from '@modern-js/utils/universal';
+import type { ModuleFederation, ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import type { EffectApiModule } from '../module';
+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;
+};
+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,3 @@
+import type { BackendFederationManifest, BackendFederationManifestAdapterOptions } from './types';
+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;

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

@@ -0,0 +1,51 @@
+import type { ModuleFederation, ModuleFederationRuntimePlugin } from '@module-federation/runtime';
+import type { BackendFederatedEffectApiModule, BackendFederationRemote } from '../backend-federation';
+import type { BackendFederationManifestAdapterError } from './errors';
+export type BackendFederationManifest = Record<string, unknown>;
+export type BackendFederationVersionBoundaryExpectation = {
+    buildVersion?: string;
+    /**
+     * Delivery-unit build marker (ADR-0019). Semantically the same value as
+     * `buildVersion`; treated as an alias. If both are set and disagree the
+     * expectation itself is invalid and fails closed before any manifest
+     * comparison runs.
+     */
+    buildMarker?: string;
+    contractVersion?: string;
+    nodeAdapterVersion?: string;
+    packageName?: string;
+    remoteName?: string;
+    /**
+     * Delivery-unit identity root (ADR-0019 §3). When set, the manifest's
+     * `backendFederation.versionBoundary.deliveryUnit.unitId` (or the
+     * top-level `backendFederation.deliveryUnit.unitId` fallback) must match.
+     */
+    unitId?: string;
+    version?: string;
+};
+export type BackendFederationManifestFetchResponse = {
+    ok: boolean;
+    status: number;
+    statusText?: string;
+    text: () => Promise<string>;
+};
+export type BackendFederationManifestAdapterFallback = (error: BackendFederationManifestAdapterError, context: {
+    manifest?: BackendFederationManifest;
+    remote?: BackendFederationRemote;
+}) => BackendFederatedEffectApiModule | Promise<BackendFederatedEffectApiModule>;
+export type BackendFederationManifestAdapterOptions = {
+    allowLegacyManifest?: boolean;
+    env?: Record<string, string | undefined>;
+    expected?: BackendFederationVersionBoundaryExpectation;
+    fallback?: BackendFederationManifestAdapterFallback;
+    fetch?: (url: string) => Promise<BackendFederationManifestFetchResponse>;
+    hostName: string;
+    manifest?: BackendFederationManifest;
+    manifestEnv?: string;
+    manifestPath?: string;
+    manifestUrl?: string;
+    plugins?: ModuleFederationRuntimePlugin[];
+    remote?: Partial<BackendFederationRemote>;
+    runtime?: ModuleFederation;
+    timeoutMs?: number;
+};

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

@@ -0,0 +1,5 @@
+import { type BackendFederatedEffectApiModule, type BackendFederationRemote } from '../backend-federation';
+import type { BackendFederationManifest, BackendFederationVersionBoundaryExpectation } from './types';
+export declare function validateBackendFederationManifest(manifest: BackendFederationManifest, expected?: BackendFederationVersionBoundaryExpectation): void;
+export declare function validateLoadedBackendFederationContract(loaded: BackendFederatedEffectApiModule, manifest: BackendFederationManifest, remote: BackendFederationRemote): void;
+export declare function classifyLoadError(error: unknown): "remote_unavailable" | "strict_effect_required";

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

@@ -1,60 +1 @@
-import type { ModuleFederation, ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-import { type BackendFederatedEffectApiModule, type BackendFederationRemote } from './backend-federation';
-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 type BackendFederationManifest = Record<string, unknown>;
-export type BackendFederationVersionBoundaryExpectation = {
-    buildVersion?: string;
-    /**
-     * Delivery-unit build marker (ADR-0019). Semantically the same value as
-     * `buildVersion`; treated as an alias. If both are set and disagree the
-     * expectation itself is invalid and fails closed before any manifest
-     * comparison runs.
-     */
-    buildMarker?: string;
-    contractVersion?: string;
-    nodeAdapterVersion?: string;
-    packageName?: string;
-    remoteName?: string;
-    /**
-     * Delivery-unit identity root (ADR-0019 §3). When set, the manifest's
-     * `backendFederation.versionBoundary.deliveryUnit.unitId` (or the
-     * top-level `backendFederation.deliveryUnit.unitId` fallback) must match.
-     */
-    unitId?: string;
-    version?: string;
-};
-export type BackendFederationManifestFetchResponse = {
-    ok: boolean;
-    status: number;
-    statusText?: string;
-    text: () => Promise<string>;
-};
-export type BackendFederationManifestAdapterFallback = (error: BackendFederationManifestAdapterError, context: {
-    manifest?: BackendFederationManifest;
-    remote?: BackendFederationRemote;
-}) => BackendFederatedEffectApiModule | Promise<BackendFederatedEffectApiModule>;
-export type BackendFederationManifestAdapterOptions = {
-    env?: Record<string, string | undefined>;
-    expected?: BackendFederationVersionBoundaryExpectation;
-    fallback?: BackendFederationManifestAdapterFallback;
-    fetch?: (url: string) => Promise<BackendFederationManifestFetchResponse>;
-    hostName: string;
-    manifest?: BackendFederationManifest;
-    manifestEnv?: string;
-    manifestPath?: string;
-    manifestUrl?: string;
-    plugins?: ModuleFederationRuntimePlugin[];
-    remote?: Partial<BackendFederationRemote>;
-    runtime?: ModuleFederation;
-    timeoutMs?: number;
-};
-export declare function loadBackendFederationManifest(options: Pick<BackendFederationManifestAdapterOptions, 'env' | 'fetch' | 'manifest' | 'manifestEnv' | 'manifestPath' | 'manifestUrl' | 'timeoutMs'>): Promise<BackendFederationManifest>;
-export declare function resolveBackendFederationRemoteFromManifest(manifest: BackendFederationManifest, remoteOverride?: Partial<BackendFederationRemote>): BackendFederationRemote;
-export declare function loadBackendFederatedEffectApiFromManifest(options: BackendFederationManifestAdapterOptions): Promise<BackendFederatedEffectApiModule>;
+export * from './backend-federation-manifest/index';

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

@@ -1,60 +1,6 @@
-import type { ModuleFederation, ModuleFederationRuntimePlugin } from '@module-federation/runtime';
-import type { EffectApiModule } from './module';
-export declare const BACKEND_FEDERATION_EFFECT_EXPOSE = "./effect-api";
-export declare const BACKEND_FEDERATION_MANIFEST_FILE = "backend-mf-manifest.json";
-export declare const BACKEND_FEDERATION_CONTRACT_VERSION = "microvertical-server-effect-v1";
-export declare const BACKEND_FEDERATION_NODE_ADAPTER_VERSION = "backend-mf-effect-v1";
-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
-             * the 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>;
-};
-type BackendFederationLoadOptions = BackendFederationRuntimeOptions & {
-    runtime?: ModuleFederation;
-    remoteName?: string;
-    expose?: string;
-};
-export declare function createBackendFederationRuntime(options: BackendFederationRuntimeOptions): ModuleFederation;
-export declare function createBackendFederationLoadEntryPlugin(options: BackendFederationLoadEntryPluginOptions): ModuleFederationRuntimePlugin;
-export declare function loadBackendFederatedEffectApi(options: BackendFederationLoadOptions): Promise<BackendFederatedEffectApiModule>;
-export {};
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from '@modern-js/utils/universal';
+export { loadBackendFederatedEffectApi } from './backend-federation/load';
+export { createBackendFederationLoadEntryPlugin } from './backend-federation/plugin';
+export { createBackendFederationRuntime } from './backend-federation/runtime';
+export type { BackendFederatedEffectApiModule, BackendFederationEntryExports, BackendFederationLoadEntryPluginOptions, BackendFederationRemote, BackendFederationRuntimeOptions, } from './backend-federation/types';
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, };

package/dist/types/runtime/effect/handler/batch-handler.d.ts

@@ -0,0 +1,11 @@
+import type { EffectDataPlatformValidationOptions } from './types';
+type DataPlatformBatchItemHandler<TContext> = (request: Request, context?: TContext) => Promise<unknown>;
+export declare function createDataPlatformBatchRequestHandler<TContext>(options: {
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    handleItem: DataPlatformBatchItemHandler<TContext>;
+}): {
+    enabled: boolean;
+    path: `/${string}`;
+    handle: (request: Request, context?: TContext) => Promise<Response>;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { type DataBatchRequestPayload, type DataBatchResponseItem } from '../../data-platform';
+export declare function normalizeBatchPath(pathname: string | undefined): `/${string}`;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function toTextLength(value: string): number;
+export declare function toHeaderRecord(headers: Headers): Record<string, string>;
+export declare function normalizeItemMethod(method: string | undefined): string;
+export declare function normalizeBatchAllowedMethods(allowedMethods: string[] | undefined): Set<string>;
+type ParsedBatchRequestPayload = Omit<DataBatchRequestPayload, 'items'> & {
+    items: unknown[];
+};
+export declare function isBatchRequestPayload(value: unknown): value is ParsedBatchRequestPayload;
+export declare function createBatchValidationResponse(message: string, status?: number): Response;
+export declare function prepareJsonRequestBody(request: Request): Promise<Request | Response>;
+export declare function toBatchItemError(id: string, status: number, message: string): DataBatchResponseItem;
+export declare function promiseWithTimeout<T>(effect: Promise<T>, timeoutMs: number): Promise<T>;
+export declare function mapWithConcurrency<TItem, TResult>(items: readonly TItem[], concurrency: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;
+export {};

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

@@ -0,0 +1,17 @@
+import type { HttpApi } from 'effect/unstable/httpapi';
+import type { Rpc } from 'effect/unstable/rpc';
+import type { EffectBffRuntime, EffectDataPlatformValidationOptions, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcRuntimeLayer, EffectRuntimeLayer } from './types';
+export declare function defineEffectBff<TApi extends HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any>(definition: {
+    api: TApi;
+    layer: TLayer;
+    rpc?: EffectRpcBffDefinition<TRpcs>;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+}): {
+    api: TApi;
+    layer: TLayer;
+    rpc?: EffectRpcBffDefinition<TRpcs>;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+} & EffectBffRuntime<TApi, TLayer>;
+export declare function defineEffectRpcBff<TRpcs extends Rpc.Any = Rpc.Any, TLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>>(definition: EffectRpcBffDefinition<TRpcs, TLayer>): EffectRpcBffDefinition<TRpcs, TLayer> & {
+    createHandler: EffectRpcBffHandlerFactory<TRpcs>;
+};

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

@@ -0,0 +1,13 @@
+import type { EffectDataPlatformValidationOptions } from './types';
+/**
+ * Validates the `x-modernjs-data-envelope` header (the data-platform
+ * transport/cache contract: protocol version, scope, selection plan).
+ *
+ * This is NOT a security boundary: the envelope is client-constructed cache
+ * metadata used for batching, scope keys and hydration. Cross-project
+ * authorization runs through the bff-core policy evaluator wired in via
+ * `validateRequest` (see `EffectRequestValidator`), which both the direct
+ * and batched request paths hit before this check.
+ */
+export declare function validateDataPlatformRequestEnvelope(request: Request, options: EffectDataPlatformValidationOptions | undefined): Response | null;
+export declare function mergeDataPlatformOptions(base: EffectDataPlatformValidationOptions | undefined, override: Partial<EffectDataPlatformValidationOptions> | undefined): EffectDataPlatformValidationOptions | undefined;