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

package/dist/esm-node/effect/handler/batch-handler.mjs

@@ -3,6 +3,7 @@ import { DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, decodeRequestE
 import { decodeBatchBody, isBatchBody, toBatchResponseItem } from "../../data-platform/batch/protocol.mjs";
 import { BatchItemTimeoutError, createBatchValidationResponse, isBatchRequestPayload, mapWithConcurrency, normalizeBatchAllowedMethods, normalizeBatchPath, promiseWithTimeout, toBatchItemError } from "./batch.mjs";
 import { getMountedPrefixFromContext, removeMountedPrefixFromBatchPath } from "./routing.mjs";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
 const HOP_BY_HOP_BATCH_ITEM_HEADERS = new Set([
     'connection',
     'keep-alive',
@@ -185,25 +186,25 @@ function createDataPlatformBatchRequestHandler(options) {
                 return toBatchResponseItem(itemId, itemResponse, 'HEAD' === itemMethod);
             } catch (error) {
                 if (error instanceof BatchItemTimeoutError) {
-                    console.error({
+                    __rspack_external_effect_Effect_41060786.runSync(__rspack_external_effect_Effect_41060786.logError({
                         event: 'bff.batch.item.timeout',
                         batchId: payload.batchId,
                         itemId,
                         method: itemMethod,
                         path: itemPathname,
                         errorName: error.name
-                    });
+                    }));
                     return toBatchItemError(itemId, 504, 'Batch item request timed out');
                 }
                 if (error instanceof Response) return toBatchResponseItem(itemId, error, 'HEAD' === itemMethod);
-                console.error({
+                __rspack_external_effect_Effect_41060786.runSync(__rspack_external_effect_Effect_41060786.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/dist/esm-node/effect/handler/batch.mjs

@@ -1,6 +1,7 @@
 import "node:module";
 import { DEFAULT_DATA_BATCH_ENDPOINT, isPlainObject, normalizeMethod } from "../../data-platform/index.mjs";
 import { encodeBatchText } from "../../data-platform/batch/protocol.mjs";
+import * as __rspack_external_effect_Data_2b3f4efb from "effect/Data";
 function normalizeBatchPath(pathname) {
     if (!pathname || '/' === pathname) return DEFAULT_DATA_BATCH_ENDPOINT;
     if (!pathname.startsWith('/')) return `/${pathname}`;
@@ -65,7 +66,13 @@ function toBatchItemError(id, status, message) {
         }))
     };
 }
-class BatchItemTimeoutError extends Error {
+class BatchItemTimeoutError extends __rspack_external_effect_Data_2b3f4efb.TaggedError('BatchItemTimeoutError') {
+    constructor(message){
+        super({
+            message
+        });
+        this.name = 'Error';
+    }
 }
 function promiseWithTimeout(effect, timeoutMs, onTimeout) {
     if (timeoutMs <= 0) return effect;

package/dist/esm-node/effect/handler/definition.mjs

@@ -21,30 +21,10 @@ function defineEffectBff(definition) {
             validateRequest: options?.validateRequest
         });
     });
-    const client = createLoaderMaterializedClientPlaceholder();
     return {
         ...definition,
-        createHandler,
-        client
-    };
-}
-const LOADER_CLIENT_IGNORED_KEYS = new Set([
-    'then',
-    'catch',
-    'finally',
-    'toJSON',
-    '$$typeof'
-]);
-function createLoaderMaterializedClientPlaceholder() {
-    const explain = (property)=>{
-        throw new Error(`[BFF][Effect] client.${String(property)} is not available here: the typed client only exists when the API entry is imported through the "@api/index" transformed path (the BFF loader replaces it with generated client code). On the server, use HttpApiClient or call the Effect layer directly.`);
+        createHandler
     };
-    return new Proxy(Object.create(null), {
-        get (_target, property) {
-            if ('symbol' == typeof property || LOADER_CLIENT_IGNORED_KEYS.has(property)) return;
-            return explain(property);
-        }
-    });
 }
 function defineEffectRpcBff(definition) {
     const createHandler = (options)=>createRpcApiHandler({

package/dist/esm-node/effect/module.mjs

@@ -12,7 +12,7 @@ function shareDispose(dispose) {
         return disposePromise;
     };
 }
-function rejectLegacyEffectModuleShape(options, shape) {
+function rejectUnsupportedEffectModuleShape(options, shape) {
     options.onWarning?.(`${strictEffectApproachMessage} Rejected ${shape}.`);
     return true;
 }
@@ -40,8 +40,8 @@ function classifyEffectBffRuntimeEntryShape(module) {
 }
 function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
     if (!facts) return null;
-    if (facts.legacyShape) {
-        if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) return null;
+    if (facts.unsupportedShape) {
+        if (rejectUnsupportedEffectModuleShape(options, facts.unsupportedShape)) return null;
     }
     if ('function' == typeof facts.createHandler) {
         if (facts.createHandlerValidatorAware) {
@@ -54,7 +54,7 @@ function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
             return createLoadedHandler(webHandler);
         }
         if (void 0 === facts.api || !facts.hasRuntimeLayer) {
-            rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export');
+            rejectUnsupportedEffectModuleShape(options, 'unbranded `createHandler` export');
             return null;
         }
         options.onWarning?.(`${strictEffectApproachMessage} Ignored unbranded \`createHandler\` export and rebuilt the handler from its { api, layer } exports.`);

package/dist/esm-node/effect/operation-context.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { BFF_LOCALE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, BFF_TRACEPARENT_HEADER, parseTraceparent } from "@modern-js/create-request";
+import { BFF_LOCALE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, BFF_TRACEPARENT_HEADER, parseTraceparent } from "@modern-js/runtime-extensions/request-context";
 const kEffectContextStorage = Symbol.for('modernjs.plugin-bff.effectContextStorage');
 const readHeader = (headers, header)=>{
     const value = headers.get(header);

package/dist/esm-node/effect-client/cross-project.mjs

@@ -0,0 +1,55 @@
+import "node:module";
+import { BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, resolveCrossProjectRequestObservation } from "@modern-js/server-runtime-extensions/bff-policy";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { HttpApi } from "effect/unstable/httpapi";
+import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
+import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
+const encodeJson = __rspack_external_effect_Schema_6065f72d.encodeSync(__rspack_external_effect_Schema_6065f72d.fromJsonString(__rspack_external_effect_Schema_6065f72d.Unknown));
+function withCrossProjectPolicy(api, options, client) {
+    const contracts = {};
+    const prefix = options.prefix.replace(/\/$/, '');
+    HttpApi.reflect(api, {
+        onGroup: ()=>{},
+        onEndpoint: ({ endpoint })=>{
+            const routePath = `${prefix}${'/' === endpoint.path ? '' : endpoint.path}` || '/';
+            const name = endpoint.identifier;
+            contracts[`${endpoint.method}:${routePath}`] = {
+                operationId: `${options.requestId}:${name}`,
+                name,
+                method: endpoint.method,
+                routePath
+            };
+        }
+    });
+    return client.pipe(HttpClient.mapRequestEffect((request)=>{
+        const observed = resolveCrossProjectRequestObservation({
+            method: request.method,
+            pathname: new URL(request.url, 'http://effect.invalid').pathname
+        }, {
+            expectedOperationContracts: contracts
+        });
+        const contract = observed && contracts[`${observed.method}:${observed.routePath}`];
+        if (void 0 === contract) return __rspack_external_effect_Effect_41060786.die(new Error('[BFF][Effect] Request has no matching shared operation contract.'));
+        return __rspack_external_effect_Effect_41060786.gen(function*() {
+            const input = encodeJson({
+                httpMethod: contract.method,
+                name: contract.name,
+                requestId: options.requestId,
+                routePath: contract.routePath
+            });
+            const digest = yield* __rspack_external_effect_Effect_41060786.promise(()=>globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(input)));
+            const schemaHash = Array.from(new Uint8Array(digest), (value)=>value.toString(16).padStart(2, '0')).join('');
+            return request.pipe(HttpClientRequest.setHeader(BFF_ENVELOPE_HEADER, encodeJson({
+                requestId: options.requestId
+            })), HttpClientRequest.setHeader(BFF_OPERATION_CONTEXT_HEADER, contract.operationId), HttpClientRequest.setHeader(BFF_OPERATION_CONTEXT_DETAIL_HEADER, encodeJson({
+                requestId: options.requestId,
+                operationId: contract.operationId,
+                method: contract.method,
+                routePath: contract.routePath,
+                schemaHash,
+                operationVersion: options.operationVersion
+            })));
+        });
+    }));
+}
+export { withCrossProjectPolicy };

package/dist/esm-node/effect-client/index.mjs

@@ -1,11 +1,12 @@
 import "node:module";
-import { createRequestContextHeaders } from "@modern-js/create-request";
+import { createRequestContextHeaders } from "@modern-js/runtime-extensions/request-context";
 import * as __rspack_external_effect_Effect_41060786 from "effect/Effect";
 import * as __rspack_external_effect_Layer_69c46453 from "effect/Layer";
 import { FetchHttpClient, HttpClient, HttpClientRequest } 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 { getRpcSerializationLayer } from "../effect/rpcSerialization.mjs";
+import { withCrossProjectPolicy } from "./cross-project.mjs";
 import * as __rspack_external_effect_Schema_6065f72d from "effect/Schema";
 import * as __rspack_external_effect_unstable_http_HttpClientError_4b9eaee6 from "effect/unstable/http/HttpClientError";
 import * as __rspack_external_effect_Data_2b3f4efb from "effect/Data";
@@ -47,7 +48,8 @@ function makeEffectHttpApiClient(api, options) {
             for (const [header, value] of Object.entries(requestContextHeaders))if (void 0 === nextRequest.headers[header.toLowerCase()]) nextRequest = HttpClientRequest.setHeader(nextRequest, header, value);
             return nextRequest;
         }));
-        return 'function' == typeof options?.transformClient ? options.transformClient(contextClient) : contextClient;
+        const policyClient = options?.crossProject !== void 0 ? withCrossProjectPolicy(api, options.crossProject, contextClient) : contextClient;
+        return 'function' == typeof options?.transformClient ? options.transformClient(policyClient) : policyClient;
     };
     return HttpApiClient.make(api, {
         baseUrl: options?.baseUrl,

package/dist/esm-node/microvertical-api.mjs

@@ -0,0 +1,68 @@
+import "node:module";
+import { Schema } from "effect";
+const MicroVerticalAppIdSchema = Schema.String.pipe(Schema.brand('MicroVerticalAppId'), Schema.decodeTo(Schema.String));
+const MicroVerticalUnitIdSchema = Schema.String.pipe(Schema.brand('MicroVerticalUnitId'), Schema.decodeTo(Schema.String));
+const MicroVerticalOperationIdSchema = Schema.String.pipe(Schema.brand('MicroVerticalOperationId'), Schema.decodeTo(Schema.String));
+const MicroVerticalTraceIdSchema = Schema.String.pipe(Schema.brand('MicroVerticalTraceId'), Schema.decodeTo(Schema.String));
+const MicroVerticalBuildMarkerSchema = Schema.Struct({
+    appId: MicroVerticalAppIdSchema,
+    build: Schema.String,
+    buildMarker: Schema.String,
+    deployProfile: Schema.String,
+    packageName: Schema.String,
+    sourceRevision: Schema.String,
+    surface: Schema.String,
+    unitId: MicroVerticalUnitIdSchema,
+    version: Schema.String
+});
+const MicroVerticalReadinessSchema = Schema.Struct({
+    checks: Schema.Struct({
+        api: Schema.Literal('ready'),
+        moduleFederation: Schema.Literal('ready'),
+        ssr: Schema.Literal('ready'),
+        translations: Schema.Literal('ready')
+    }),
+    marker: MicroVerticalBuildMarkerSchema,
+    status: Schema.Literal('ready'),
+    versionSkew: Schema.Literal('none')
+});
+const MicroVerticalOperationSourceSchema = Schema.Literals([
+    'client',
+    'server',
+    'generated-client',
+    'effect-adapter',
+    'data-platform',
+    'unknown'
+]);
+const MicroVerticalOperationContextSchema = Schema.Struct({
+    method: Schema.String,
+    operationId: MicroVerticalOperationIdSchema,
+    routePath: Schema.String,
+    source: MicroVerticalOperationSourceSchema,
+    traceId: Schema.optionalKey(MicroVerticalTraceIdSchema)
+});
+const createMicroVerticalOperationContext = (input)=>{
+    const context = {
+        method: input.method,
+        operationId: input.operationId,
+        routePath: input.routePath,
+        source: 'generated-client'
+    };
+    return void 0 === input.traceId ? context : {
+        ...context,
+        traceId: input.traceId
+    };
+};
+const microVerticalOperationAttributes = (operationContext)=>{
+    const attributes = {
+        'modernjs.operation.id': operationContext.operationId,
+        'modernjs.operation.method': operationContext.method,
+        'modernjs.operation.route': operationContext.routePath,
+        'modernjs.operation.source': operationContext.source
+    };
+    return void 0 === operationContext.traceId ? attributes : {
+        ...attributes,
+        'modernjs.trace.id': operationContext.traceId
+    };
+};
+export { MicroVerticalBuildMarkerSchema, MicroVerticalOperationContextSchema, MicroVerticalOperationSourceSchema, MicroVerticalReadinessSchema, createMicroVerticalOperationContext, microVerticalOperationAttributes };

package/dist/types/assembly.d.ts

@@ -0,0 +1,10 @@
+/** 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 type { EffectRuntimeRequirements } from './effect/handler/types.js';
+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 declare const assembleEffectBffRuntime: <ApiId extends string, Groups extends HttpApiGroup.Constraint, HandlerRequirements extends EffectRuntimeRequirements, TransportRequirements extends EffectRuntimeRequirements = never>({ api, handlers, transport, }: EffectBffRuntimeAssembly<ApiId, Groups, HandlerRequirements, TransportRequirements>) => import("./effect/index.js").EffectBffDefinition<HttpApi.HttpApi<ApiId, Groups>, Layer.Layer<never, never, HandlerRequirements | TransportRequirements | Exclude<import("effect/FileSystem").FileSystem, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/Etag").Generator, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/HttpPlatform").HttpPlatform, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/HttpRouter").HttpRouter, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/Path").Path, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<HttpApiGroup.ToService<ApiId, Groups>, HttpApiGroup.ToService<ApiId, Groups>>>, import("effect/unstable/rpc/Rpc").Any> & import("./effect/index.js").EffectBffRuntime<HttpApi.HttpApi<ApiId, Groups>, Layer.Layer<never, never, HandlerRequirements | TransportRequirements | Exclude<import("effect/FileSystem").FileSystem, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/Etag").Generator, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/HttpPlatform").HttpPlatform, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/unstable/http/HttpRouter").HttpRouter, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<import("effect/Path").Path, HttpApiGroup.ToService<ApiId, Groups>> | Exclude<HttpApiGroup.ToService<ApiId, Groups>, HttpApiGroup.ToService<ApiId, Groups>>>>;

package/dist/types/data-platform/batch/protocol.d.ts

@@ -1,4 +1,4 @@
-import type { DataBatchBody, DataBatchHeader, DataBatchResponseItem } from '../types';
+import type { DataBatchBody, DataBatchHeader, DataBatchResponseItem } from '../types.js';
 export declare function encodeBatchBody(bytes: Uint8Array): DataBatchBody;
 export declare function encodeBatchText(value: string): DataBatchBody;
 export declare function decodeBatchBody(body: DataBatchBody): Uint8Array<ArrayBuffer>;

package/dist/types/data-platform/batch/queue.d.ts

@@ -1,4 +1,4 @@
-import type { DataBatchRequestItem, DataBatchTransportOptions, DataTransportRequestInfo } from '../types';
+import type { DataBatchRequestItem, DataBatchTransportOptions, DataTransportRequestInfo } from '../types.js';
 type DataBatchFetch = NonNullable<DataBatchTransportOptions['fetch']>;
 type CreateBatchTransportQueueOptions = {
     options: DataBatchTransportOptions;

package/dist/types/data-platform/batch/request.d.ts

@@ -1,4 +1,4 @@
-import type { DataBatchBody } from '../types';
+import type { DataBatchBody } from '../types.js';
 export declare function toHeaderRecord(headers: HeadersInit | undefined): Record<string, string>;
 export declare function measureTextBytes(value: string): number;
 export declare function createBatchId(): string;

package/dist/types/data-platform/batch/response.d.ts

@@ -1,3 +1,3 @@
-import type { DataBatchResponsePayload } from '../types';
+import type { DataBatchResponsePayload } from '../types.js';
 export declare function isBatchResponsePayload(value: unknown): value is DataBatchResponsePayload;
 export declare function parseResponseLikeCreateRequest(response: Response): Promise<any>;

package/dist/types/data-platform/batch/telemetry.d.ts

@@ -1,4 +1,4 @@
-import type { DataBatchTransportEvent, DataBatchTransportTelemetryAttributes } from '../types';
+import type { DataBatchTransportEvent, DataBatchTransportTelemetryAttributes } from '../types.js';
 export declare const DATA_BATCH_TRANSPORT_OTEL_EVENT = "modernjs.data.batch";
 export declare function createDataBatchTransportTelemetryAttributes(event: DataBatchTransportEvent): DataBatchTransportTelemetryAttributes;
 export declare function emitDataBatchTransportEvent(onEvent: ((event: DataBatchTransportEvent) => void) | undefined, event: DataBatchTransportEvent): void;

package/dist/types/data-platform/batch/url.d.ts

@@ -1,4 +1,4 @@
-import type { DataTransportRequestInfo } from '../types';
+import type { DataTransportRequestInfo } from '../types.js';
 export declare function resolveRuntimeOrigin(): string;
 export declare function toAbsoluteUrl(input: DataTransportRequestInfo): URL;
 export declare function normalizeBatchEndpoint(requestUrl: URL, endpoint: string | undefined): URL;

package/dist/types/data-platform/batch-transport.d.ts

@@ -1,3 +1,3 @@
-import type { DataBatchTransportOptions } from './types';
-export { createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch/telemetry';
-export declare function createDataBatchTransport(options?: DataBatchTransportOptions): (input: import("./types").DataTransportRequestInfo, init?: RequestInit) => Promise<any>;
+import type { DataBatchTransportOptions } from './types.js';
+export { createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch/telemetry.js';
+export declare function createDataBatchTransport(options?: DataBatchTransportOptions): (input: import("./types.js").DataTransportRequestInfo, init?: RequestInit) => Promise<any>;

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

@@ -1,4 +1,4 @@
-import type { CacheScope, DataRequestMode, OperationDescriptor, RequestEnvelope, SelectionPlan } from './types';
+import type { CacheScope, DataRequestMode, OperationDescriptor, RequestEnvelope, SelectionPlan } from './types.js';
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 export declare function stableStringify(value: unknown): string;
 export declare function encodeRequestEnvelopeHeader(envelope: RequestEnvelope): string;

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

@@ -1,8 +1,8 @@
-export { measureTextBytes, normalizeMethod } from './batch/request';
-export { createDataBatchTransport, createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch-transport';
-export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, isPlainObject, normalizeOrigin, stableStringify, } from './codec';
-export { createInvalidationEvent, shouldApplyInvalidation, } from './invalidation';
-export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader, } from './trace';
-export type { CacheScope, DataBatchBody, DataBatchHeader, DataBatchRequestItem, DataBatchRequestPayload, DataBatchResponseItem, DataBatchResponsePayload, DataBatchTransportEvent, DataBatchTransportOptions, DataBatchTransportTelemetryAttributes, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, InvalidationEvent, InvalidationSubscriber, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext, } from './types';
-export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, } from './types';
-export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan, } from './validation';
+export { measureTextBytes, normalizeMethod } from './batch/request.js';
+export { createDataBatchTransport, createDataBatchTransportTelemetryAttributes, DATA_BATCH_TRANSPORT_OTEL_EVENT, emitDataBatchTransportEvent, } from './batch-transport.js';
+export { buildQueryKey, buildScopeKey, createOperationId, decodeRequestEnvelopeHeader, encodeRequestEnvelopeHeader, isPlainObject, normalizeOrigin, stableStringify, } from './codec.js';
+export { createInvalidationEvent, shouldApplyInvalidation, } from './invalidation.js';
+export { deriveChildTraceContext, formatTraceparentHeader, parseTraceparentHeader, } from './trace.js';
+export type { CacheScope, DataBatchBody, DataBatchHeader, DataBatchRequestItem, DataBatchRequestPayload, DataBatchResponseItem, DataBatchResponsePayload, DataBatchTransportEvent, DataBatchTransportOptions, DataBatchTransportTelemetryAttributes, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, InvalidationEvent, InvalidationSubscriber, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext, } from './types.js';
+export { DEFAULT_DATA_BATCH_ENDPOINT, DEFAULT_DATA_BATCH_HEADER, DEFAULT_DATA_ENVELOPE_HEADER, } from './types.js';
+export { createHydrationEnvelope, createRequestEnvelope, validateHydrationEnvelope, validateRequestEnvelope, validateSelectionPlan, } from './validation.js';

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

@@ -1,4 +1,4 @@
-import type { CacheScope, InvalidationEvent, InvalidationSubscriber, OperationDescriptor } from './types';
+import type { CacheScope, InvalidationEvent, InvalidationSubscriber, OperationDescriptor } from './types.js';
 export declare function createInvalidationEvent(input: {
     sourceOperation: OperationDescriptor;
     sourceScope: CacheScope;

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

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

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

@@ -1,4 +1,4 @@
-import type { CacheScope, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext } from './types';
+import type { CacheScope, DataMutationMode, DataRequestMode, HydrationEnvelope, HydrationEnvelopeValidationOptions, OperationDescriptor, RequestEnvelope, RequestEnvelopeValidationOptions, SelectionPlan, SelectionPlanValidationOptions, SelectionPlanValidationResult, TraceContext } from './types.js';
 export declare function validateSelectionPlan(plan: SelectionPlan, options?: SelectionPlanValidationOptions): SelectionPlanValidationResult;
 export declare function createRequestEnvelope<Input>(input: {
     operation: OperationDescriptor;

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

@@ -1,5 +1,5 @@
-import { type EffectContext } from './operation-context';
-export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
+import { type EffectContext } from './operation-context.js';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context.js';
 export declare const runWithEffectContext: <T>(context: EffectContext, cb: () => T) => T;
 export declare const useEffectContext: () => EffectContext;
-export declare const useOperationContext: () => import("@modern-js/create-request").OperationContext;
+export declare const useOperationContext: () => import("@modern-js/runtime-extensions/request-context").OperationContext;

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

@@ -1,5 +1,5 @@
-import type { EffectBffRequestHandler } from './module';
-import { type EffectContext } from './operation-context';
+import type { EffectBffRequestHandler } from './module.js';
+import { type EffectContext } from './operation-context.js';
 type EffectDispatchContextRunner = <T>(context: EffectContext, cb: () => T) => T;
 export type DispatchEffectBffRequestOptions = {
     prefix?: string;

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

@@ -1,5 +1,5 @@
-import { type EffectContext } from './operation-context';
-export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
+import { type EffectContext } from './operation-context.js';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context.js';
 export declare const runWithEffectContext: <T>(context: EffectContext, cb: () => T) => T;
 export declare const useEffectContext: () => EffectContext;
-export declare const useOperationContext: () => import("@modern-js/create-request").OperationContext;
+export declare const useOperationContext: () => import("@modern-js/runtime-extensions/request-context").OperationContext;

package/dist/types/effect/edge-dispatcher.d.ts

@@ -1,8 +1,8 @@
-import { type NormalizedCrossProjectPolicy } from '@modern-js/bff-core/security/cross-project-policy';
-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 NormalizedCrossProjectPolicy } from '@modern-js/server-runtime-extensions/bff-policy';
+import { type DispatchEffectBffRequestOptions } from './dispatch.js';
+import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions } from './handler.js';
+import { type EffectApiModule, type EffectBffRequestHandler } from './module.js';
+import type { EffectContext } from './operation-context.js';
 export * as Config from 'effect/Config';
 export * as Effect from 'effect/Effect';
 export * as Layer from 'effect/Layer';
@@ -11,10 +11,10 @@ export * as Schema from 'effect/Schema';
 export { Cookies, Etag, FetchHttpClient, FindMyWay, Headers, HttpBody, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpEffect, HttpIncomingMessage, HttpMethod, HttpMiddleware, HttpPlatform, HttpRouter, HttpServer, HttpServerError, HttpServerRequest, HttpServerRespondable, HttpServerResponse, HttpStaticServer, HttpStatus, HttpTraceContext, Multipart, MultipartParser, Template, Url, UrlParams, } from 'effect/unstable/http';
 export { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, HttpApiTest, OpenApi, } from 'effect/unstable/httpapi';
 export { Rpc, RpcClient, RpcClientError, RpcGroup, RpcMessage, RpcMiddleware, RpcSchema, RpcSerialization, RpcServer, RpcTest, RpcWorker, Utils, } from 'effect/unstable/rpc';
-export { runWithEffectContext, useEffectContext, useOperationContext, } from './edge-context';
-export type { EffectApiClientFromApi, EffectApiPromiseClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler';
-export { createHttpApiHandler, defineEffectBff, defineEffectRpcBff, } from './handler';
-export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context';
+export { runWithEffectContext, useEffectContext, useOperationContext, } from './edge-context.js';
+export type { EffectApiClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler.js';
+export { createHttpApiHandler, defineEffectBff, defineEffectRpcBff, } from './handler.js';
+export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, } from './operation-context.js';
 export type EffectBffEdgeDispatchOptions = Omit<DispatchEffectBffRequestOptions, 'runWithEffectContext'>;
 export type EffectBffEdgeHandlerOptions = {
     module: EffectApiModule;

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

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

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

@@ -1,17 +1,5 @@
-/**
- * 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.
- */
-import { type OperationContractSource } from '@modern-js/bff-core';
+/** Shared endpoint normalization and identity hashing for server policy metadata. */
+import { type OperationContractSource } from '@modern-js/server-runtime-extensions/bff-policy/node';
 export type EffectEndpointMeta = {
     apiId: string;
     groupName: string;
@@ -26,13 +14,7 @@ type HttpApiGroupLike = {
     identifier?: unknown;
 };
 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;
 };

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

@@ -5,10 +5,10 @@ type EffectBffEntryModule = {
     createHandler?: unknown;
     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;

package/dist/types/effect/generated-entry.d.ts

@@ -0,0 +1,7 @@
+import { type EffectBffEdgeHandlerOptions } from './edge-dispatcher.js';
+type OperationContracts = NonNullable<EffectBffEdgeHandlerOptions['crossProjectPolicy']>['expectedOperationContracts'];
+export declare function createEffectBffEdgeDispatcherFactory(module: EffectBffEdgeHandlerOptions['module'], generatedOperationContracts: OperationContracts): (options?: Omit<EffectBffEdgeHandlerOptions, 'module'>) => Promise<{
+    dispatch: (request: Request, dispatchOptions?: Omit<import("./edge-dispatcher.js").EffectBffEdgeDispatchOptions, 'prefix' | 'onError'>) => Promise<Response>;
+    dispose: () => Promise<void>;
+}>;
+export {};

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

@@ -1,4 +1,4 @@
-import type { EffectDataPlatformValidationOptions } from './types';
+import type { EffectDataPlatformValidationOptions } from './types.js';
 type DataPlatformBatchItemHandler<TContext> = (request: Request, context?: TContext) => Promise<unknown>;
 export declare function createDataPlatformBatchRequestHandler<TContext>(options: {
     dataPlatform?: EffectDataPlatformValidationOptions;

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

@@ -1,5 +1,5 @@
-import { type DataBatchRequestPayload, type DataBatchResponseItem } from '../../data-platform';
-export { toHeaderRecord } from '../../headers';
+import { type DataBatchRequestPayload, type DataBatchResponseItem } from '../../data-platform/index.js';
+export { toHeaderRecord } from '../../headers.js';
 export declare function normalizeBatchPath(pathname: string | undefined): `/${string}`;
 export declare function normalizeBatchAllowedMethods(allowedMethods: string[] | undefined): Set<string>;
 type ParsedBatchRequestPayload = Omit<DataBatchRequestPayload, 'items'> & {
@@ -9,7 +9,13 @@ export declare function isBatchRequestPayload(value: unknown): value is ParsedBa
 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 class BatchItemTimeoutError extends Error {
+declare const BatchItemTimeoutError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "BatchItemTimeoutError";
+} & Readonly<A>;
+export declare class BatchItemTimeoutError extends BatchItemTimeoutError_base<{
+    readonly message: string;
+}> {
+    constructor(message: string);
 }
 export declare function promiseWithTimeout<T>(effect: Promise<T>, timeoutMs: number, onTimeout?: (error: BatchItemTimeoutError) => void): Promise<T>;
 export declare function mapWithConcurrency<TItem, TResult>(items: readonly TItem[], concurrency: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;

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

@@ -1,6 +1,6 @@
 import type { HttpApi } from 'effect/unstable/httpapi';
 import type { Rpc } from 'effect/unstable/rpc';
-import type { EffectBffDefinition, EffectBffRuntime, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcRuntimeLayer, EffectRuntimeLayer } from './types';
+import type { EffectBffDefinition, EffectBffRuntime, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcRuntimeLayer, EffectRuntimeLayer } from './types.js';
 export declare function defineEffectBff<TApi extends HttpApi.Constraint, TLayer extends EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any>(definition: EffectBffDefinition<TApi, TLayer, TRpcs>): EffectBffDefinition<TApi, TLayer, TRpcs> & 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/effect/handler/envelope.d.ts

@@ -1,4 +1,4 @@
-import type { EffectDataPlatformValidationOptions } from './types';
+import type { EffectDataPlatformValidationOptions } from './types.js';
 /**
  * Validates the `x-modernjs-data-envelope` header (the data-platform
  * transport/cache contract: protocol version, scope, selection plan).

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

@@ -1,6 +1,6 @@
 import type { HttpApi } from 'effect/unstable/httpapi';
 import type { Rpc } from 'effect/unstable/rpc';
-import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestInterceptor, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types';
+import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestInterceptor, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types.js';
 export declare function createHttpApiHandler<TApi extends HttpApi.Constraint = HttpApi.Top, TRpcs extends Rpc.Any = Rpc.Any>(options: {
     api: TApi;
     layer: EffectRuntimeLayer;

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

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

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

@@ -1,5 +1,5 @@
 import { type Rpc } from 'effect/unstable/rpc';
-import type { EffectRpcBffDefinition } from './types';
+import type { EffectRpcBffDefinition } from './types.js';
 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>;