@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

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;

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" | "version_mismatch";

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

@@ -0,0 +1 @@
+export * from './backend-federation-manifest/index';

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

@@ -0,0 +1,7 @@
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION } from '@modern-js/utils/universal';
+export { type BackendFederationExpectedIdentity, type BackendFederationIdentityIssue, validateExpectedBackendFederationIdentity, } from './backend-federation/identity';
+export { loadBackendFederatedEffectApi } from './backend-federation/load';
+export { createBackendFederationLoadEntryPlugin } from './backend-federation/plugin';
+export { createBackendFederationRuntime } from './backend-federation/runtime';
+export type { BackendFederatedEffectApiModule, BackendFederationEntryExports, BackendFederationIdentityLoadOptions, 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/dispatch.d.ts

@@ -0,0 +1,13 @@
+import type { EffectBffRequestHandler } from './module';
+import { type EffectContext } from './operation-context';
+type EffectDispatchContextRunner = <T>(context: EffectContext, cb: () => T) => T;
+export type DispatchEffectBffRequestOptions = {
+    prefix?: string;
+    env?: Record<string, unknown>;
+    path?: string;
+    method?: string;
+    runWithEffectContext: EffectDispatchContextRunner;
+    onError?: (error: unknown, context: EffectContext) => Promise<Response> | Response;
+};
+export declare function dispatchEffectBffRequestWithContext(handler: EffectBffRequestHandler, request: Request, options: DispatchEffectBffRequestOptions): Promise<Response>;
+export {};

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

@@ -1,16 +1,12 @@
+import { type DispatchEffectBffRequestOptions } from './dispatch';
 import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions } from './handler';
 import { type EffectApiModule, type EffectBffRequestHandler } from './module';
-import { type EffectContext } from './operation-context';
+import type { EffectContext } from './operation-context';
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, type BackendFederatedEffectApiModule, type BackendFederationEntryExports, type BackendFederationExpectedIdentity, type BackendFederationIdentityIssue, type BackendFederationIdentityLoadOptions, type BackendFederationLoadEntryPluginOptions, type BackendFederationRemote, type BackendFederationRuntimeOptions, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi, validateExpectedBackendFederationIdentity, } from './backend-federation';
 export { runWithEffectContext, useEffectContext, useOperationContext, } from './edge-context';
 export * from './handler';
 export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
-export type EffectBffEdgeDispatchOptions = {
-    prefix?: string;
-    env?: Record<string, unknown>;
-    path?: string;
-    method?: string;
-    onError?: (error: unknown, context: EffectContext) => Promise<Response> | Response;
-};
+export type EffectBffEdgeDispatchOptions = Omit<DispatchEffectBffRequestOptions, 'runWithEffectContext'>;
 export type EffectBffEdgeHandlerOptions = {
     module: EffectApiModule;
     prefix?: string;
@@ -20,6 +16,10 @@ export type EffectBffEdgeHandlerOptions = {
     onWarning?: (message: string) => void;
 };
 export declare function dispatchEffectBffRequest(handler: EffectBffRequestHandler, request: Request, options?: EffectBffEdgeDispatchOptions): Promise<Response>;
+export declare function createEffectBffEdgeDispatcher(options: EffectBffEdgeHandlerOptions): Promise<{
+    dispatch: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
+    dispose: () => Promise<void>;
+}>;
 export declare const createEffectBffTestHandler: typeof createEffectBffEdgeHandler;
 export declare function createEffectBffEdgeHandler(options: EffectBffEdgeHandlerOptions): Promise<{
     handler: (request: Request, dispatchOptions?: Omit<EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;

package/dist/types/runtime/effect/endpoint-contracts.d.ts

@@ -21,10 +21,10 @@ export type EffectEndpointMeta = {
 export type HttpApiLike = {
     identifier?: unknown;
 };
-export type HttpApiGroupLike = {
+type HttpApiGroupLike = {
     identifier?: unknown;
 };
-export type HttpApiEndpointLike = {
+type HttpApiEndpointLike = {
     name?: unknown;
     method?: unknown;
     path?: unknown;
@@ -39,8 +39,6 @@ export type HttpApiReflect = (api: unknown, handlers: {
 }) => void;
 export declare function ensureLeadingSlash(pathname: string): string;
 export declare function normalizeEffectPrefix(prefix: string): string;
-export declare function getEffectRoutePath(prefix: string, endpointPath: string): string;
-export declare function resolveEffectApiId(api: HttpApiLike): string;
 export declare function collectEffectEndpoints(reflect: HttpApiReflect, api: HttpApiLike, prefix: string): EffectEndpointMeta[];
 /**
  * Maps reflected endpoints onto operation-contract sources for
@@ -48,11 +46,10 @@ export declare function collectEffectEndpoints(reflect: HttpApiReflect, api: Htt
  * carry no zod metadata, so the contract hash covers the endpoint identity.
  */
 export declare function toOperationContractSources(endpoints: EffectEndpointMeta[]): OperationContractSource[];
-export declare function createEffectOperationContractSource(endpoint: EffectEndpointMeta): OperationContractSource;
 /**
  * Extracts the HttpApi instance from a loaded effect entry module. Mirrors
- * the module shapes accepted by `resolveEffectBffModuleHandler`:
- * `{ api }`, `{ default: { api } }` and zero-arg default factories.
+ * the shared entry-shape policy accepted by `resolveEffectBffModuleHandler`,
+ * without executing factories during contract extraction.
  */
 export declare function extractHttpApiFromModule(mod: unknown, isHttpApi: (value: unknown) => boolean): Promise<HttpApiLike | null>;
 /**
@@ -60,3 +57,4 @@ export declare function extractHttpApiFromModule(mod: unknown, isHttpApi: (value
  * contract map (it is the same bff-core hash over the same inputs).
  */
 export declare function createEffectEndpointContractHash(endpoint: EffectEndpointMeta, requestId: string): string;
+export {};

package/dist/types/runtime/effect/entry-shape.d.ts

@@ -0,0 +1,31 @@
+type EffectBffEntryModule = {
+    api?: unknown;
+    layer?: unknown;
+    handler?: unknown;
+    createHandler?: unknown;
+    default?: unknown;
+};
+type LegacyEffectBffEntryShape = '`handler` export' | 'default request handler';
+export type EffectBffEntryShapeFacts = {
+    module: EffectBffEntryModule;
+    legacyShape?: LegacyEffectBffEntryShape;
+    createHandler?: unknown;
+    createHandlerValidatorAware: boolean;
+    api?: unknown;
+    layer?: unknown;
+    hasRuntimeLayer: boolean;
+};
+type EffectBffEntryShapePredicates = {
+    isRequestHandler: (value: unknown) => boolean;
+    isValidatorAwareHandlerFactory: (value: unknown) => boolean;
+    isHttpApi: (value: unknown) => boolean;
+};
+export declare const EFFECT_VALIDATOR_AWARE_FACTORY: symbol;
+/**
+ * True when a custom createHandler factory is produced by defineEffectBff and
+ * therefore forwards strict cross-project validation into createHttpApiHandler.
+ */
+export declare function isValidatorAwareHandlerFactory(factory: unknown): boolean;
+export declare const strictEffectApproachMessage = "[BFF][Effect] strictEffectApproach is enforced: Effect API entries export defineEffectBff(...) or { api, layer } HttpApi module. Raw handler exports, default request handlers, unbranded custom createHandler factories not valid Effect API entries.";
+export declare function classifyEffectBffEntryModule(value: unknown, predicates: EffectBffEntryShapePredicates): EffectBffEntryShapeFacts | null;
+export {};

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;

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

@@ -0,0 +1,14 @@
+import type { HttpApi } from 'effect/unstable/httpapi';
+import type { Rpc } from 'effect/unstable/rpc';
+import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types';
+export declare function createHttpApiHandler<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TRpcs extends Rpc.Any = Rpc.Any>(options: {
+    api: TApi;
+    layer: EffectRuntimeLayer;
+    openapi?: EffectBffOpenApiConfig;
+    rpc?: EffectRpcBffDefinition<TRpcs>;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    validateRequest?: EffectRequestValidator;
+}): {
+    handler: (request: Request, context?: Parameters<(request: globalThis.Request, context: import("effect/Context").Context<unknown>) => Promise<Response>>[1]) => Promise<Response>;
+    dispose: () => Promise<void>;
+};

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

@@ -0,0 +1,4 @@
+import { HttpRouter } from 'effect/unstable/http';
+import { type HttpApi } from 'effect/unstable/httpapi';
+import type { EffectBffOpenApiConfig } from './types';
+export declare function createOpenApiLayer(api: HttpApi.AnyWithProps, openapi: EffectBffOpenApiConfig | undefined): import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter> | null;

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

@@ -0,0 +1,5 @@
+export declare function getRequestPathname(request: Request): string;
+export declare function getMountedPrefixFromContext(request: Request, context: unknown): string;
+export declare function removeMountedPrefixFromBatchPath(pathWithQuery: string, prefix: string): string;
+export declare function getExpectedEnvelopeOrigin(request: Request): string;
+export declare function isRpcRequest(request: Request, rpcPath: `/${string}`): boolean;

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

@@ -0,0 +1,7 @@
+import { type Rpc } from 'effect/unstable/rpc';
+import type { EffectRpcBffDefinition } from './types';
+export declare function normalizeRpcPath(pathname: string | undefined): `/${string}`;
+export declare function createRpcApiHandler<TRpcs extends Rpc.Any = Rpc.Any>(options: EffectRpcBffDefinition<TRpcs>): {
+    readonly handler: (request: globalThis.Request, context?: import("effect/Context").Context<never> | undefined) => Promise<Response>;
+    readonly dispose: () => Promise<void>;
+};

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

@@ -0,0 +1,148 @@
+import type { FileSystem, Path } from 'effect';
+import * as Context from 'effect/Context';
+import type * as EffectType from 'effect/Effect';
+import type * as Layer from 'effect/Layer';
+import type { Etag, HttpPlatform, HttpRouter } from 'effect/unstable/http';
+import type { HttpApi, HttpApiClient, HttpApiGroup } from 'effect/unstable/httpapi';
+import type { Rpc, RpcGroup } from 'effect/unstable/rpc';
+import type { createHttpApiHandler } from './http';
+import type { createRpcApiHandler } from './rpc';
+export type EffectRuntimeRequirements = Etag.Generator | FileSystem.FileSystem | HttpPlatform.HttpPlatform | HttpRouter.HttpRouter | HttpRouter.Request<'Error', unknown> | HttpRouter.Request<'GlobalError', unknown> | HttpRouter.Request<'GlobalRequires', unknown> | HttpRouter.Request<'Requires', unknown> | Path.Path;
+export type EffectRuntimeLayer = Layer.Layer<never, never, EffectRuntimeRequirements>;
+export declare const toEffectServiceContext: (context: unknown) => Context.Context<any>;
+export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
+export type EffectRpcRuntimeLayer<TRpcs extends Rpc.Any = Rpc.Any> = Layer.Layer<Rpc.ToHandler<TRpcs> | Rpc.Middleware<TRpcs> | Rpc.ServicesServer<TRpcs>, unknown, never>;
+export type EffectRpcBffDefinition<TRpcs extends Rpc.Any = Rpc.Any, TRpcLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>> = {
+    group: RpcGroup.RpcGroup<TRpcs>;
+    layer: TRpcLayer;
+    path?: `/${string}`;
+    serialization?: EffectRpcSerialization;
+    disableTracing?: boolean;
+    spanPrefix?: string;
+    spanAttributes?: Record<string, unknown>;
+    disableFatalDefects?: boolean;
+};
+export type EffectRpcBffHandlerOptions = Pick<EffectRpcBffDefinition, 'path' | 'serialization' | 'disableTracing' | 'spanPrefix' | 'spanAttributes' | 'disableFatalDefects'>;
+type EffectApiPromiseClient<TClient> = {
+    [GroupName in keyof TClient]: {
+        [EndpointName in keyof TClient[GroupName]]: TClient[GroupName][EndpointName] extends (...args: infer TArgs) => infer TResult ? TResult extends EffectType.Effect<unknown, unknown, unknown> ? (...args: TArgs) => Promise<Exclude<EffectType.Success<TResult>, readonly [unknown, unknown]>> : never : never;
+    };
+};
+export type EffectApiClientFromApi<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Any>, never, never> : never;
+export type EffectApiPromiseClientFromApi<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
+export type EffectBffDefinition<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
+    api: TApi;
+    layer: TLayer;
+    rpc?: EffectRpcBffDefinition<TRpcs>;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+};
+export type EffectDataPlatformSelectionValidationOptions = {
+    maxDepth?: number;
+    maxFields?: number;
+    allowedLeafPaths?: string[];
+};
+export type EffectDataPlatformBatchOptions = {
+    /**
+     * Enable network batching endpoint for Effect HttpApi requests.
+     * Defaults to `true`.
+     */
+    enabled?: boolean;
+    /**
+     * Batch endpoint path mounted under BFF prefix.
+     * Defaults to `/_data/batch`.
+     */
+    endpoint?: `/${string}`;
+    /**
+     * Maximum request items accepted per batch call.
+     * Defaults to `16`.
+     */
+    maxBatchSize?: number;
+    /**
+     * Maximum serialized request payload size in bytes.
+     * Defaults to `65536` (64KiB).
+     */
+    maxBatchBytes?: number;
+    /**
+     * Client-side micro-batch flush window in milliseconds.
+     * Server runtime ignores this value and passes it through for codegen.
+     * Defaults to `8`.
+     */
+    flushIntervalMs?: number;
+    /**
+     * Maximum per-batch internal request concurrency.
+     * Defaults to `4`.
+     */
+    maxConcurrency?: number;
+    /**
+     * Optional timeout per internal request in milliseconds.
+     * Defaults to `10000`.
+     */
+    requestTimeoutMs?: number;
+    /**
+     * Allowed HTTP methods for internal batched dispatch.
+     * Defaults to `['GET']`.
+     */
+    allowedMethods?: string[];
+};
+export type EffectDataPlatformValidationOptions = {
+    /**
+     * Enable envelope validation for HttpApi requests.
+     * Defaults to `true`.
+     */
+    enabled?: boolean;
+    /**
+     * Require every HttpApi request to include an envelope header.
+     * Defaults to `false`.
+     */
+    requireEnvelope?: boolean;
+    /**
+     * Header name used by client/server for the serialized request envelope.
+     * Defaults to `x-modernjs-data-envelope`.
+     */
+    envelopeHeader?: string;
+    /**
+     * Optional namespace assertion for envelope validation.
+     */
+    expectedNamespace?: string;
+    /**
+     * Validate envelope origin against incoming request origin.
+     * Defaults to `true`.
+     */
+    validateOrigin?: boolean;
+    /**
+     * Require trace context inside request envelope.
+     * Defaults to `false`.
+     */
+    requireTraceContext?: boolean;
+    /**
+     * Selection plan guardrails for server-side validation.
+     */
+    selection?: EffectDataPlatformSelectionValidationOptions;
+    /**
+     * Network batching gateway configuration.
+     */
+    batch?: EffectDataPlatformBatchOptions;
+};
+/**
+ * Server-seam request validator applied to every HttpApi request — direct,
+ * batched (per item) and rpc. Returning a Response short-circuits the
+ * request; returning `null`/`undefined` lets it through. Used by the effect
+ * adapter to enforce the cross-project policy at one seam so batched items
+ * cannot bypass it.
+ */
+export type EffectRequestValidator = (request: Request) => Response | null | undefined;
+export type EffectBffHandlerFactory<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
+    openapi?: EffectBffOpenApiConfig;
+    rpc?: Partial<EffectRpcBffHandlerOptions>;
+    dataPlatform?: Partial<EffectDataPlatformValidationOptions>;
+    validateRequest?: EffectRequestValidator;
+}) => ReturnType<typeof createHttpApiHandler>;
+export type EffectBffRuntime<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = {
+    createHandler: EffectBffHandlerFactory<TApi, TLayer>;
+    client: EffectApiPromiseClientFromApi<TApi>;
+};
+export type EffectBffOpenApiConfig = boolean | {
+    path?: string;
+};
+export type EffectRpcBffHandlerFactory<TRpcs extends Rpc.Any = Rpc.Any> = (options?: Partial<EffectRpcBffHandlerOptions>) => ReturnType<typeof createRpcApiHandler<TRpcs>>;
+export {};