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

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

@@ -1,12 +1,11 @@
 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';
+import type { createHttpApiHandler } from './http.js';
+import type { createRpcApiHandler } from './rpc.js';
 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>;
@@ -23,13 +22,7 @@ export type EffectRpcBffDefinition<TRpcs extends Rpc.Any = Rpc.Any, TRpcLayer ex
     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.Constraint = HttpApi.Top> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Constraint>, never, never> : never;
-export type EffectApiPromiseClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
 export type EffectBffDefinition<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
     api: TApi;
     layer: TLayer;
@@ -63,12 +56,6 @@ export type EffectDataPlatformBatchOptions = {
      * 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`.
@@ -144,10 +131,8 @@ export type EffectBffHandlerFactory<TApi extends HttpApi.Constraint = HttpApi.To
 }) => ReturnType<typeof createHttpApiHandler>;
 export type EffectBffRuntime<TApi extends HttpApi.Constraint = HttpApi.Top, 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 {};

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

@@ -8,6 +8,6 @@ export { HttpTraceContext } from 'effect/unstable/http';
 export * from 'effect/unstable/httpapi';
 export { HttpApiBuilder } from 'effect/unstable/httpapi';
 export * from 'effect/unstable/rpc';
-export { defineEffectBff, defineEffectRpcBff } from './handler/definition';
-export { createHttpApiHandler } from './handler/http';
-export type { EffectApiClientFromApi, EffectApiPromiseClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler/types';
+export { defineEffectBff, defineEffectRpcBff } from './handler/definition.js';
+export { createHttpApiHandler } from './handler/http.js';
+export type { EffectApiClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler/types.js';

package/dist/types/effect/index.d.ts

@@ -1,6 +1,6 @@
 export * as OpenTelemetry from '@effect/opentelemetry';
-export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, runWithEffectContext, useEffectContext, useOperationContext, } from './context';
-export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, } from './edge';
-export * from './endpoint-contracts';
-export * from './handler';
-export { type EffectApiModule, type EffectBffHandlerFactory, type EffectBffRequestHandler, resolveEffectBffModuleHandler, } from './module';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, runWithEffectContext, useEffectContext, useOperationContext, } from './context.js';
+export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, } from './edge.js';
+export * from './endpoint-contracts.js';
+export * from './handler.js';
+export { type EffectApiModule, type EffectBffHandlerFactory, type EffectBffRequestHandler, resolveEffectBffModuleHandler, } from './module.js';

package/dist/types/effect/module.d.ts

@@ -1,6 +1,6 @@
 import type * as EffectServiceContext from 'effect/Context';
-import { type EffectBffOpenApiConfig, type EffectDataPlatformValidationOptions, type EffectRequestValidator } from './handler';
-import type { EffectContext } from './operation-context';
+import { type EffectBffOpenApiConfig, type EffectDataPlatformValidationOptions, type EffectRequestValidator } from './handler.js';
+import type { EffectContext } from './operation-context.js';
 export type EffectBffRequestHandler = (request: Request, context?: EffectServiceContext.Context<any> | EffectContext) => Promise<Response> | Response;
 export type EffectBffHandlerFactory = (options?: {
     openapi?: EffectBffOpenApiConfig;

package/dist/types/effect/operation-context.d.ts

@@ -1,4 +1,4 @@
-import { type OperationContext } from '@modern-js/create-request';
+import { type OperationContext } from '@modern-js/runtime-extensions/request-context';
 export type EffectContext = {
     request: Request;
     env: Record<string, unknown>;

package/dist/types/effect/rpcSerialization.d.ts

@@ -1,3 +1,3 @@
 import { RpcSerialization } from 'effect/unstable/rpc';
-import type { EffectRpcSerialization } from './handler/types';
+import type { EffectRpcSerialization } from './handler/types.js';
 export declare function getRpcSerializationLayer(serialization: EffectRpcSerialization | undefined): import("effect/Layer").Layer<RpcSerialization.RpcSerialization, never, never>;

package/dist/types/effect-client/cross-project.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from 'effect/unstable/http';
+import { HttpApi, type HttpApiGroup } from 'effect/unstable/httpapi';
+export interface EffectCrossProjectClientOptions {
+    requestId: string;
+    operationVersion: number;
+    /** Server mount path, independent of the API origin. */
+    prefix: string;
+}
+/** Native transport middleware; endpoint encoding and inference stay in Effect. */
+export declare function withCrossProjectPolicy<Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>, options: EffectCrossProjectClientOptions, client: HttpClient.HttpClient): HttpClient.HttpClient;

package/dist/types/effect-client/index.d.ts

@@ -1,15 +1,18 @@
-import { type RequestContextInput } from '@modern-js/create-request';
+import { type RequestContextInput } from '@modern-js/runtime-extensions/request-context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import { HttpClient } from 'effect/unstable/http';
 import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from 'effect/unstable/httpapi';
 import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from 'effect/unstable/rpc';
+import { type EffectCrossProjectClientOptions } from './cross-project.js';
 export * as Effect from 'effect/Effect';
 export * as Layer from 'effect/Layer';
 export * as Schema from 'effect/Schema';
 export * as HttpClientError from 'effect/unstable/http/HttpClientError';
+export type { EffectCrossProjectClientOptions } from './cross-project.js';
 export { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, };
 export type EffectHttpApiClientOptions = {
+    crossProject?: EffectCrossProjectClientOptions;
     baseUrl?: URL | string;
     requestContext?: RequestContextInput;
     transformClient?: (client: HttpClient.HttpClient) => HttpClient.HttpClient;

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
-export * as DataPlatform from './data-platform';
-export * from './effect';
-export * as EffectClient from './effect-client';
+export * as DataPlatform from './data-platform/index.js';
+export * from './effect/index.js';
+export * as EffectClient from './effect-client/index.js';

package/dist/types/microvertical-api.d.ts

@@ -0,0 +1,65 @@
+import { Schema } from 'effect';
+export declare const MicroVerticalBuildMarkerSchema: Schema.Struct<{
+    readonly appId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalAppId">>;
+    readonly build: Schema.String;
+    readonly buildMarker: Schema.String;
+    readonly deployProfile: Schema.String;
+    readonly packageName: Schema.String;
+    readonly sourceRevision: Schema.String;
+    readonly surface: Schema.String;
+    readonly unitId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalUnitId">>;
+    readonly version: Schema.String;
+}>;
+export type MicroVerticalBuildMarker = typeof MicroVerticalBuildMarkerSchema.Type;
+export declare const MicroVerticalReadinessSchema: Schema.Struct<{
+    readonly checks: Schema.Struct<{
+        readonly api: Schema.Literal<"ready">;
+        readonly moduleFederation: Schema.Literal<"ready">;
+        readonly ssr: Schema.Literal<"ready">;
+        readonly translations: Schema.Literal<"ready">;
+    }>;
+    readonly marker: Schema.Struct<{
+        readonly appId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalAppId">>;
+        readonly build: Schema.String;
+        readonly buildMarker: Schema.String;
+        readonly deployProfile: Schema.String;
+        readonly packageName: Schema.String;
+        readonly sourceRevision: Schema.String;
+        readonly surface: Schema.String;
+        readonly unitId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalUnitId">>;
+        readonly version: Schema.String;
+    }>;
+    readonly status: Schema.Literal<"ready">;
+    readonly versionSkew: Schema.Literal<"none">;
+}>;
+export type MicroVerticalReadiness = typeof MicroVerticalReadinessSchema.Type;
+export declare const MicroVerticalOperationSourceSchema: Schema.Literals<readonly ["client", "server", "generated-client", "effect-adapter", "data-platform", "unknown"]>;
+export type MicroVerticalOperationSource = typeof MicroVerticalOperationSourceSchema.Type;
+export declare const MicroVerticalOperationContextSchema: Schema.Struct<{
+    readonly method: Schema.String;
+    readonly operationId: Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalOperationId">>;
+    readonly routePath: Schema.String;
+    readonly source: Schema.Literals<readonly ["client", "server", "generated-client", "effect-adapter", "data-platform", "unknown"]>;
+    readonly traceId: Schema.optionalKey<Schema.compose<Schema.String, Schema.brand<Schema.String, "MicroVerticalTraceId">>>;
+}>;
+export type MicroVerticalOperationContext = typeof MicroVerticalOperationContextSchema.Type;
+export declare const createMicroVerticalOperationContext: <const Method extends string, const OperationId extends string, const RoutePath extends string>(input: {
+    readonly method: Method;
+    readonly operationId: OperationId;
+    readonly routePath: RoutePath;
+    readonly traceId?: string;
+}) => Readonly<typeof input & {
+    source: 'generated-client';
+}>;
+export declare const microVerticalOperationAttributes: (operationContext: MicroVerticalOperationContext) => {
+    'modernjs.operation.id': string;
+    'modernjs.operation.method': string;
+    'modernjs.operation.route': string;
+    'modernjs.operation.source': "client" | "data-platform" | "effect-adapter" | "generated-client" | "server" | "unknown";
+} | {
+    'modernjs.operation.id': string;
+    'modernjs.operation.method': string;
+    'modernjs.operation.route': string;
+    'modernjs.operation.source': "client" | "data-platform" | "effect-adapter" | "generated-client" | "server" | "unknown";
+    'modernjs.trace.id': string;
+};

package/package.json

@@ -18,7 +18,7 @@
     "modern.js",
     "ultramodern.js"
   ],
-  "version": "3.8.3-ultramodern.6",
+  "version": "3.9.0-ultramodern.10",
   "files": [
     "dist",
     "src"
@@ -67,14 +67,14 @@
       "import": "./dist/esm/effect-client/index.mjs",
       "default": "./dist/esm/effect-client/index.mjs"
     },
-    "./effect-client-runtime": {
-      "types": "./dist/types/effect-client/runtime.d.ts",
+    "./microvertical-api": {
+      "types": "./dist/types/microvertical-api.d.ts",
       "node": {
-        "import": "./dist/esm-node/effect-client/runtime.mjs",
-        "require": "./dist/cjs/effect-client/runtime.js"
+        "import": "./dist/esm-node/microvertical-api.mjs",
+        "require": "./dist/cjs/microvertical-api.js"
       },
-      "import": "./dist/esm/effect-client/runtime.mjs",
-      "default": "./dist/esm/effect-client/runtime.mjs"
+      "import": "./dist/esm/microvertical-api.mjs",
+      "default": "./dist/esm/microvertical-api.mjs"
     },
     "./data-platform": {
       "types": "./dist/types/data-platform/index.d.ts",
@@ -84,6 +84,14 @@
       },
       "import": "./dist/esm/data-platform/index.mjs",
       "default": "./dist/esm/data-platform/index.mjs"
+    },
+    "./assembly": {
+      "types": "./dist/types/assembly.d.ts",
+      "node": {
+        "import": "./dist/esm-node/assembly.mjs",
+        "require": "./dist/cjs/assembly.js"
+      },
+      "default": "./dist/esm/assembly.mjs"
     }
   },
   "typesVersions": {
@@ -104,13 +112,17 @@
         "./dist/types/effect-client/index.d.ts",
         "./src/effect-client/index.ts"
       ],
-      "effect-client-runtime": [
-        "./dist/types/effect-client/runtime.d.ts",
-        "./src/effect-client/runtime.ts"
+      "microvertical-api": [
+        "./dist/types/microvertical-api.d.ts",
+        "./src/microvertical-api.ts"
       ],
       "data-platform": [
         "./dist/types/data-platform/index.d.ts",
         "./src/data-platform/index.ts"
+      ],
+      "assembly": [
+        "./dist/types/assembly.d.ts",
+        "./src/assembly.ts"
       ]
     }
   },
@@ -118,17 +130,18 @@
     "node": ">=26.7.0"
   },
   "dependencies": {
-    "@modern-js/bff-core": "npm:@bleedingdev/modern-js-bff-core@3.8.3-ultramodern.6",
-    "@modern-js/create-request": "npm:@bleedingdev/modern-js-create-request@3.8.3-ultramodern.6",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.8.3-ultramodern.6",
+    "@modern-js/bff-core": "npm:@bleedingdev/modern-js-bff-core@3.9.0-ultramodern.10",
+    "@modern-js/create-request": "npm:@bleedingdev/modern-js-create-request@3.9.0-ultramodern.10",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.10",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.10",
     "@opentelemetry/api": "1.9.1",
-    "@opentelemetry/api-logs": "0.220.0",
-    "@opentelemetry/resources": "2.9.0",
-    "@opentelemetry/sdk-logs": "0.220.0",
-    "@opentelemetry/sdk-metrics": "2.9.0",
-    "@opentelemetry/sdk-trace-base": "2.9.0",
-    "@opentelemetry/sdk-trace-node": "2.9.0",
-    "@opentelemetry/sdk-trace-web": "2.9.0",
+    "@opentelemetry/api-logs": "0.222.0",
+    "@opentelemetry/resources": "2.11.0",
+    "@opentelemetry/sdk-logs": "0.222.0",
+    "@opentelemetry/sdk-metrics": "2.11.0",
+    "@opentelemetry/sdk-trace-base": "2.11.0",
+    "@opentelemetry/sdk-trace-node": "2.11.0",
+    "@opentelemetry/sdk-trace-web": "2.11.0",
     "@opentelemetry/semantic-conventions": "1.43.0"
   },
   "peerDependencies": {
@@ -145,9 +158,9 @@
   },
   "devDependencies": {
     "@effect/opentelemetry": "4.0.0-rc.112",
-    "@rslib/core": "0.23.2",
+    "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "@types/react": "^19.2.18",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "effect": "4.0.0-rc.112"

package/src/assembly.ts

@@ -0,0 +1,43 @@
+/** Server-only assembly for the invariant tail of a strict Effect BFF runtime factory. */
+import * as Layer from 'effect/Layer';
+import type { HttpApi, HttpApiGroup } from 'effect/unstable/httpapi';
+import { HttpApiBuilder } from 'effect/unstable/httpapi';
+import { defineEffectBff } from './effect/handler/definition';
+import type { EffectRuntimeRequirements } from './effect/handler/types';
+
+export interface EffectBffRuntimeAssembly<
+  ApiId extends string,
+  Groups extends HttpApiGroup.Constraint,
+  HandlerRequirements extends EffectRuntimeRequirements,
+  TransportRequirements extends EffectRuntimeRequirements = never,
+> {
+  readonly api: HttpApi.HttpApi<ApiId, Groups>;
+  readonly handlers: Layer.Layer<
+    HttpApiGroup.ToService<ApiId, Groups>,
+    never,
+    HandlerRequirements
+  >;
+  readonly transport?: Layer.Layer<never, never, TransportRequirements>;
+}
+
+export const assembleEffectBffRuntime = <
+  ApiId extends string,
+  Groups extends HttpApiGroup.Constraint,
+  HandlerRequirements extends EffectRuntimeRequirements,
+  TransportRequirements extends EffectRuntimeRequirements = never,
+>({
+  api,
+  handlers,
+  transport,
+}: EffectBffRuntimeAssembly<
+  ApiId,
+  Groups,
+  HandlerRequirements,
+  TransportRequirements
+>) => {
+  const apiLayer = HttpApiBuilder.layer(api).pipe(Layer.provide(handlers));
+  const layer =
+    transport === undefined ? apiLayer : apiLayer.pipe(Layer.merge(transport));
+
+  return defineEffectBff({ api, layer });
+};

package/src/data-platform/batch/queue.ts

@@ -307,15 +307,14 @@ export function createBatchTransportQueue({
     abortBatchIfUnused?.();
   };
 
-  const runSingle = (request: QueuedBatchRequest) => {
-    return runWithSignal(request.lifetime.signal, async () => {
+  const runSingle = (request: QueuedBatchRequest) =>
+    runWithSignal(request.lifetime.signal, async () => {
       const response = await baseFetch(
         request.requestInput,
         request.requestInit,
       );
       return parseResponseLikeCreateRequest(response);
     });
-  };
 
   const settleRequests = async (
     items: QueuedBatchRequest[],

package/src/data-platform/trace.ts

@@ -1,5 +1,5 @@
 // @effect-diagnostics asyncFunction:off globalDate:off globalRandom:off globalTimers:off newPromise:off strictBooleanExpressions:off
-import { parseTraceparent } from '@modern-js/create-request';
+import { parseTraceparent } from '@modern-js/runtime-extensions/request-context';
 
 import type { TraceContext } from './types';
 

package/src/effect/edge-dispatcher.ts

@@ -3,7 +3,8 @@ import {
   evaluateCrossProjectPolicy,
   type NormalizedCrossProjectPolicy,
   resolveCrossProjectRequestObservation,
-} from '@modern-js/bff-core/security/cross-project-policy';
+} from '@modern-js/server-runtime-extensions/bff-policy';
+import * as Effect from 'effect/Effect';
 import { toHeaderRecord } from '../headers';
 import {
   type DispatchEffectBffRequestOptions,
@@ -91,7 +92,6 @@ export {
 } from './edge-context';
 export type {
   EffectApiClientFromApi,
-  EffectApiPromiseClientFromApi,
   EffectBffDefinition,
   EffectBffHandlerFactory,
   EffectBffOpenApiConfig,
@@ -285,9 +285,11 @@ export async function createEffectBffEdgeDispatcher(
       disposePromise ??= (async () => {
         acceptingRequests = false;
         if (activeDispatches > 0) {
-          await new Promise<void>(resolve => {
-            resolveDrain = resolve;
-          });
+          await Effect.runPromise(
+            Effect.callback<void>(resume => {
+              resolveDrain = () => resume(Effect.void);
+            }),
+          );
         }
         await loaded.dispose?.();
       })();

package/src/effect/edge.ts

@@ -1 +1,2 @@
 export * from './edge-dispatcher';
+export { createEffectBffEdgeDispatcherFactory } from './generated-entry';

package/src/effect/endpoint-contracts.ts

@@ -1,21 +1,9 @@
 // @effect-diagnostics asyncFunction:off strictBooleanExpressions:off
-/**
- * Shared Effect HttpApi endpoint reflection used by BOTH sides of the
- * cross-project contract:
- *
- * - the `@modern-js/plugin-bff-extensions/client-generator` package stamps
- *   each generated operation with a per-endpoint contract hash;
- * - the `@modern-js/plugin-bff-extensions/effect-adapter` package derives the
- *   expected operation-contract map for the cross-project policy from the
- *   same endpoints.
- *
- * Keeping route-path normalization and the endpoint -> contract mapping in
- * one module is what guarantees the two hashes agree.
- */
+/** Shared endpoint normalization and identity hashing for server policy metadata. */
 import {
   createOperationContractHash,
   type OperationContractSource,
-} from '@modern-js/bff-core';
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
 import {
   classifyEffectBffEntryModule,
   isValidatorAwareHandlerFactory,
@@ -38,13 +26,7 @@ type HttpApiGroupLike = {
 };
 
 type HttpApiEndpointLike = {
-  /**
-   * effect 4.0.0-beta.98 renamed the endpoint `name` property to `identifier`,
-   * matching `HttpApiGroup`. `name` is kept as a fallback so reflection over an
-   * older Effect build does not silently degrade to the class name.
-   */
   identifier?: unknown;
-  name?: unknown;
   method?: unknown;
   path?: unknown;
 };
@@ -53,9 +35,6 @@ function resolveEffectEndpointName(endpoint: HttpApiEndpointLike): string {
   if (typeof endpoint.identifier === 'string' && endpoint.identifier) {
     return endpoint.identifier;
   }
-  if (typeof endpoint.name === 'string' && endpoint.name) {
-    return endpoint.name;
-  }
   return '';
 }
 
@@ -168,7 +147,7 @@ export async function extractHttpApiFromModule(
     isValidatorAwareHandlerFactory,
     isHttpApi,
   });
-  return facts?.legacyShape ||
+  return facts?.unsupportedShape ||
     facts?.api === undefined ||
     !facts.hasRuntimeLayer ||
     (facts.createHandler !== undefined && !facts.createHandlerValidatorAware)

package/src/effect/entry-shape.ts

@@ -42,8 +42,11 @@ function loadNodeValidatorAwareHandlerFactoryRegistry(): ValidatorAwareHandlerFa
   }
 }
 
+declare const __MODERN_EFFECT_NODE_RUNTIME__: boolean;
+
 const validatorAwareHandlerFactoryRegistry =
-  process.env.MODERN_EFFECT_NODE_RUNTIME === 'true'
+  typeof __MODERN_EFFECT_NODE_RUNTIME__ !== 'undefined' &&
+  __MODERN_EFFECT_NODE_RUNTIME__
     ? loadNodeValidatorAwareHandlerFactoryRegistry()
     : createLocalValidatorAwareHandlerFactoryRegistry();
 
@@ -55,11 +58,13 @@ type EffectBffEntryModule = {
   default?: unknown;
 };
 
-type LegacyEffectBffEntryShape = '`handler` export' | 'default request handler';
+type UnsupportedEffectBffEntryShape =
+  | '`handler` export'
+  | 'default request handler';
 
 export type EffectBffEntryShapeFacts = {
   module: EffectBffEntryModule;
-  legacyShape?: LegacyEffectBffEntryShape;
+  unsupportedShape?: UnsupportedEffectBffEntryShape;
   createHandler?: unknown;
   createHandlerValidatorAware: boolean;
   api?: unknown;
@@ -132,7 +137,7 @@ export function classifyEffectBffEntryModule(
 function createEntryShapeFacts(
   module: EffectBffEntryModule,
   predicates: EffectBffEntryShapePredicates,
-  legacyShape?: LegacyEffectBffEntryShape,
+  unsupportedShape?: UnsupportedEffectBffEntryShape,
 ): EffectBffEntryShapeFacts {
   const createHandler =
     typeof module.createHandler === 'function'
@@ -143,7 +148,7 @@ function createEntryShapeFacts(
 
   return {
     module,
-    legacyShape,
+    unsupportedShape,
     createHandler,
     createHandlerValidatorAware:
       createHandler !== undefined &&

package/src/effect/generated-entry.ts

@@ -0,0 +1,36 @@
+import {
+  createEffectBffEdgeDispatcher,
+  type EffectBffEdgeHandlerOptions,
+} from './edge-dispatcher';
+
+type OperationContracts = NonNullable<
+  EffectBffEdgeHandlerOptions['crossProjectPolicy']
+>['expectedOperationContracts'];
+
+export function createEffectBffEdgeDispatcherFactory(
+  module: EffectBffEdgeHandlerOptions['module'],
+  generatedOperationContracts: OperationContracts,
+) {
+  return (options?: Omit<EffectBffEdgeHandlerOptions, 'module'>) => {
+    const policy = options?.crossProjectPolicy;
+    const crossProjectPolicy =
+      policy === undefined ||
+      policy === null ||
+      policy.expectedOperationContracts === null ||
+      typeof policy.expectedOperationContracts !== 'object' ||
+      Array.isArray(policy.expectedOperationContracts)
+        ? policy
+        : {
+            ...policy,
+            expectedOperationContracts: {
+              ...policy.expectedOperationContracts,
+              ...generatedOperationContracts,
+            },
+          };
+    return createEffectBffEdgeDispatcher({
+      ...options,
+      crossProjectPolicy,
+      module,
+    });
+  };
+}

package/src/effect/handler/batch-handler.ts

@@ -1,4 +1,5 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
+import * as Effect from 'effect/Effect';
 import {
   type DataBatchResponsePayload,
   DEFAULT_DATA_BATCH_HEADER,
@@ -417,14 +418,16 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
           );
         } catch (error) {
           if (error instanceof BatchItemTimeoutError) {
-            console.error({
-              event: 'bff.batch.item.timeout',
-              batchId: payload.batchId,
-              itemId,
-              method: itemMethod,
-              path: itemPathname,
-              errorName: error.name,
-            });
+            Effect.runSync(
+              Effect.logError({
+                event: 'bff.batch.item.timeout',
+                batchId: payload.batchId,
+                itemId,
+                method: itemMethod,
+                path: itemPathname,
+                errorName: error.name,
+              }),
+            );
             return toBatchItemError(
               itemId,
               504,
@@ -435,14 +438,16 @@ export function createDataPlatformBatchRequestHandler<TContext>(options: {
             return toBatchResponseItem(itemId, error, itemMethod === 'HEAD');
           }
 
-          console.error({
-            event: 'bff.batch.item.failure',
-            batchId: payload.batchId,
-            itemId,
-            method: itemMethod,
-            path: itemPathname,
-            errorName: error instanceof Error ? error.name : 'UnknownError',
-          });
+          Effect.runSync(
+            Effect.logError({
+              event: 'bff.batch.item.failure',
+              batchId: payload.batchId,
+              itemId,
+              method: itemMethod,
+              path: itemPathname,
+              errorName: error instanceof Error ? error.name : 'UnknownError',
+            }),
+          );
           return toBatchItemError(itemId, 500, 'Internal Server Error');
         } finally {
           request.signal.removeEventListener('abort', abortFromBatchRequest);

package/src/effect/handler/batch.ts

@@ -1,5 +1,6 @@
 // @effect-diagnostics anyUnknownInErrorContext:off asyncFunction:off globalDate:off globalTimers:off newPromise:off strictBooleanExpressions:off
 
+import * as Data from 'effect/Data';
 import {
   type DataBatchRequestPayload,
   type DataBatchResponseItem,
@@ -117,7 +118,14 @@ export function toBatchItemError(
   };
 }
 
-export class BatchItemTimeoutError extends Error {}
+export class BatchItemTimeoutError extends Data.TaggedError(
+  'BatchItemTimeoutError',
+)<{ readonly message: string }> {
+  constructor(message: string) {
+    super({ message });
+    this.name = 'Error';
+  }
+}
 
 export function promiseWithTimeout<T>(
   effect: Promise<T>,