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

package/src/effect/handler/definition.ts

@@ -7,7 +7,6 @@ import { mergeDataPlatformOptions } from './envelope';
 import { createHttpApiHandler } from './http';
 import { createRpcApiHandler } from './rpc';
 import type {
-  EffectApiPromiseClientFromApi,
   EffectBffDefinition,
   EffectBffHandlerFactory,
   EffectBffRuntime,
@@ -51,55 +50,12 @@ export function defineEffectBff<
       validateRequest: options?.validateRequest,
     });
   });
-  const client = createLoaderMaterializedClientPlaceholder<TApi>();
   return {
     ...definition,
     createHandler,
-    client,
   };
 }
 
-const LOADER_CLIENT_IGNORED_KEYS = new Set<PropertyKey>([
-  'then',
-  'catch',
-  'finally',
-  'toJSON',
-  '$$typeof',
-]);
-
-/**
- * `defineEffectBff(...).client` is only materialized when the entry module
- * is imported through the `@api/index` transform (the webpack/rspack
- * loader swaps the module for generated client code). Importing the entry
- * directly (server code, scripts, tests) used to return a `client` typed as
- * fully functional but `undefined` at runtime — a bare TypeError with zero
- * explanation. This placeholder keeps the type contract while failing with
- * an actionable error on first property access.
- */
-function createLoaderMaterializedClientPlaceholder<
-  TApi extends HttpApi.Constraint,
->(): EffectApiPromiseClientFromApi<TApi> {
-  const explain = (property: PropertyKey): never => {
-    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.`,
-    );
-  };
-
-  return new Proxy(Object.create(null), {
-    get(_target, property) {
-      // Keep async/inspection protocols (await, console.log, React internals)
-      // from throwing so the placeholder stays inert until really used.
-      if (
-        typeof property === 'symbol' ||
-        LOADER_CLIENT_IGNORED_KEYS.has(property)
-      ) {
-        return undefined;
-      }
-      return explain(property);
-    },
-  }) as EffectApiPromiseClientFromApi<TApi>;
-}
-
 export function defineEffectRpcBff<
   TRpcs extends Rpc.Any = Rpc.Any,
   TLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>,

package/src/effect/handler/http.ts

@@ -66,8 +66,8 @@ export function createHttpApiHandler<
   ) => {
     // Policy seam first: every HttpApi request, direct or batched item,
     // passes through here, so batch fan-out cannot bypass validator. The
-    // interceptor receives the original request and may own malformed or
-    // legacy payloads; delegated requests still pass through body validation.
+    // interceptor receives the original request; delegated requests still
+    // pass through body validation.
     const policyDenial = options.validateRequest?.(request);
     if (policyDenial) {
       return policyDenial;

package/src/effect/handler/types.ts

@@ -77,22 +77,6 @@ export type EffectRpcBffHandlerOptions = Pick<
   | '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,
 > =
@@ -104,10 +88,6 @@ export type EffectApiClientFromApi<
       >
     : 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,
@@ -147,12 +127,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`.
@@ -241,7 +215,6 @@ export type EffectBffRuntime<
   TLayer extends EffectRuntimeLayer = EffectRuntimeLayer,
 > = {
   createHandler: EffectBffHandlerFactory<TApi, TLayer>;
-  client: EffectApiPromiseClientFromApi<TApi>;
 };
 
 export type EffectBffOpenApiConfig =

package/src/effect/handler.ts

@@ -14,7 +14,6 @@ export { defineEffectBff, defineEffectRpcBff } from './handler/definition';
 export { createHttpApiHandler } from './handler/http';
 export type {
   EffectApiClientFromApi,
-  EffectApiPromiseClientFromApi,
   EffectBffDefinition,
   EffectBffHandlerFactory,
   EffectBffOpenApiConfig,

package/src/effect/module.ts

@@ -67,7 +67,7 @@ function shareDispose(dispose: () => Promise<void>) {
   };
 }
 
-function rejectLegacyEffectModuleShape(
+function rejectUnsupportedEffectModuleShape(
   options: ResolveEffectBffModuleHandlerOptions,
   shape: string,
 ) {
@@ -119,8 +119,8 @@ function resolveClassifiedEffectBffModuleHandler(
     return null;
   }
 
-  if (facts.legacyShape) {
-    if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) {
+  if (facts.unsupportedShape) {
+    if (rejectUnsupportedEffectModuleShape(options, facts.unsupportedShape)) {
       return null;
     }
   }
@@ -137,7 +137,7 @@ function resolveClassifiedEffectBffModuleHandler(
     }
 
     if (facts.api === undefined || !facts.hasRuntimeLayer) {
-      rejectLegacyEffectModuleShape(
+      rejectUnsupportedEffectModuleShape(
         options,
         'unbranded `createHandler` export',
       );

package/src/effect/operation-context.ts

@@ -6,7 +6,7 @@ import {
   BFF_TRACEPARENT_HEADER,
   type OperationContext,
   parseTraceparent,
-} from '@modern-js/create-request';
+} from '@modern-js/runtime-extensions/request-context';
 
 export type EffectContext = {
   request: Request;

package/src/effect-client/cross-project.ts

@@ -0,0 +1,109 @@
+import {
+  BFF_ENVELOPE_HEADER,
+  BFF_OPERATION_CONTEXT_DETAIL_HEADER,
+  BFF_OPERATION_CONTEXT_HEADER,
+  resolveCrossProjectRequestObservation,
+} from '@modern-js/server-runtime-extensions/bff-policy';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
+
+import { HttpClient, HttpClientRequest } 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 function withCrossProjectPolicy<
+  Id extends string,
+  Groups extends HttpApiGroup.Constraint,
+>(
+  api: HttpApi.HttpApi<Id, Groups>,
+  options: EffectCrossProjectClientOptions,
+  client: HttpClient.HttpClient,
+): HttpClient.HttpClient {
+  const contracts: Record<
+    string,
+    { operationId: string; name: string; method: string; routePath: string }
+  > = {};
+  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 (contract === undefined) {
+        return Effect.die(
+          new Error(
+            '[BFF][Effect] Request has no matching shared operation contract.',
+          ),
+        );
+      }
+      return Effect.gen(function* () {
+        // Canonical field order matches the server's route-identity SHA-256.
+        const input = encodeJson({
+          httpMethod: contract.method,
+          name: contract.name,
+          requestId: options.requestId,
+          routePath: contract.routePath,
+        });
+        const digest = yield* Effect.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,
+            }),
+          ),
+        );
+      });
+    }),
+  );
+}

package/src/effect-client/index.ts

@@ -2,7 +2,7 @@
 import {
   createRequestContextHeaders,
   type RequestContextInput,
-} from '@modern-js/create-request';
+} from '@modern-js/runtime-extensions/request-context';
 import * as Data from 'effect/Data';
 import * as Effect from 'effect/Effect';
 import * as Exit from 'effect/Exit';
@@ -30,11 +30,16 @@ import {
 } from 'effect/unstable/rpc';
 
 import { getRpcSerializationLayer } from '../effect/rpcSerialization';
+import {
+  type EffectCrossProjectClientOptions,
+  withCrossProjectPolicy,
+} from './cross-project';
 
 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';
 export {
   HttpApi,
   HttpApiClient,
@@ -49,6 +54,7 @@ export {
 };
 
 export type EffectHttpApiClientOptions = {
+  crossProject?: EffectCrossProjectClientOptions;
   baseUrl?: URL | string;
   requestContext?: RequestContextInput;
   transformClient?: (client: HttpClient.HttpClient) => HttpClient.HttpClient;
@@ -233,9 +239,13 @@ export function makeEffectHttpApiClient<
             }),
           );
 
+    const policyClient =
+      options?.crossProject !== undefined
+        ? withCrossProjectPolicy(api, options.crossProject, contextClient)
+        : contextClient;
     return typeof options?.transformClient === 'function'
-      ? options.transformClient(contextClient)
-      : contextClient;
+      ? options.transformClient(policyClient)
+      : policyClient;
   };
 
   return HttpApiClient.make(api, {

package/src/microvertical-api.ts

@@ -0,0 +1,102 @@
+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),
+);
+
+export 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,
+});
+export type MicroVerticalBuildMarker =
+  typeof MicroVerticalBuildMarkerSchema.Type;
+
+export 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'),
+});
+export type MicroVerticalReadiness = typeof MicroVerticalReadinessSchema.Type;
+
+export const MicroVerticalOperationSourceSchema = Schema.Literals([
+  'client',
+  'server',
+  'generated-client',
+  'effect-adapter',
+  'data-platform',
+  'unknown',
+]);
+export type MicroVerticalOperationSource =
+  typeof MicroVerticalOperationSourceSchema.Type;
+
+export const MicroVerticalOperationContextSchema = Schema.Struct({
+  method: Schema.String,
+  operationId: MicroVerticalOperationIdSchema,
+  routePath: Schema.String,
+  source: MicroVerticalOperationSourceSchema,
+  traceId: Schema.optionalKey(MicroVerticalTraceIdSchema),
+});
+export type MicroVerticalOperationContext =
+  typeof MicroVerticalOperationContextSchema.Type;
+
+export const createMicroVerticalOperationContext = <
+  const Method extends string,
+  const OperationId extends string,
+  const RoutePath extends string,
+>(input: {
+  readonly method: Method;
+  readonly operationId: OperationId;
+  readonly routePath: RoutePath;
+  // eslint-disable-next-line effect-native/no-threaded-correlation-parameter -- This pure browser-safe contract deliberately carries optional trace metadata; it does not perform ambient request work.
+  readonly traceId?: string;
+}): Readonly<typeof input & { source: 'generated-client' }> => {
+  const context = {
+    method: input.method,
+    operationId: input.operationId,
+    routePath: input.routePath,
+    source: 'generated-client' as const,
+  };
+  return input.traceId === undefined
+    ? context
+    : { ...context, traceId: input.traceId };
+};
+
+export const microVerticalOperationAttributes = (
+  operationContext: MicroVerticalOperationContext,
+) => {
+  const attributes = {
+    'modernjs.operation.id': operationContext.operationId,
+    'modernjs.operation.method': operationContext.method,
+    'modernjs.operation.route': operationContext.routePath,
+    'modernjs.operation.source': operationContext.source,
+  };
+  return operationContext.traceId === undefined
+    ? attributes
+    : { ...attributes, 'modernjs.trace.id': operationContext.traceId };
+};

package/dist/cjs/effect-client/batch.js

@@ -1,73 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    configureGeneratedEffectClientRuntime: ()=>configureGeneratedEffectClientRuntime
-});
-const index_js_namespaceObject = require("../data-platform/index.js");
-const external_envelope_js_namespaceObject = require("./envelope.js");
-const resolveRuntimeFetch = ()=>'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
-const configureGeneratedEffectClientRuntime = (config, configureRequest)=>{
-    const defaultOrigin = config.defaultOrigin;
-    if (config.requestId && configureRequest) {
-        const configurePayload = {
-            requestId: config.requestId,
-            requireEnvelope: true,
-            identityBinding: {
-                enabled: true,
-                strict: true
-            },
-            operationContract: {
-                enabled: true,
-                strict: true,
-                requireSchemaHash: true,
-                requireOperationVersion: true
-            },
-            setDomain: ()=>(0, external_envelope_js_namespaceObject.resolveOrigin)(defaultOrigin)
-        };
-        const runtimeFetch = resolveRuntimeFetch();
-        if (false !== config.batch.enabled && runtimeFetch) configurePayload.request = (0, index_js_namespaceObject.createDataBatchTransport)({
-            fetch: runtimeFetch,
-            endpoint: config.batch.endpoint,
-            flushIntervalMs: config.batch.flushIntervalMs,
-            maxBatchSize: config.batch.maxBatchSize,
-            maxBatchBytes: config.batch.maxBatchBytes,
-            requestTimeoutMs: config.batch.requestTimeoutMs,
-            allowedMethods: config.batch.allowedMethods
-        });
-        configureRequest(configurePayload);
-    }
-};
-exports.configureGeneratedEffectClientRuntime = __webpack_exports__.configureGeneratedEffectClientRuntime;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "configureGeneratedEffectClientRuntime"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/effect-client/envelope.js

@@ -1,145 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    prepareEffectRequest: ()=>prepareEffectRequest,
-    resolveOrigin: ()=>resolveOrigin
-});
-const index_js_namespaceObject = require("../data-platform/index.js");
-const external_guards_js_namespaceObject = require("./guards.js");
-const external_request_js_namespaceObject = require("./request.js");
-const external_request_context_js_namespaceObject = require("./request-context.js");
-const DATA_REQUEST_MODES = new Set([
-    'cache-first',
-    'stale-while-revalidate',
-    'network-only'
-]);
-const DATA_MUTATION_MODES = new Set([
-    'optimistic',
-    'pessimistic',
-    'fire-and-forget'
-]);
-const isDataRequestMode = (value)=>'string' == typeof value && DATA_REQUEST_MODES.has(value);
-const isDataMutationMode = (value)=>'string' == typeof value && DATA_MUTATION_MODES.has(value);
-const normalizeOrigin = (value)=>{
-    if ('string' != typeof value || 0 === value.length) return;
-    try {
-        return new URL(value).origin;
-    } catch  {
-        return;
-    }
-};
-const resolveOrigin = (defaultOrigin)=>{
-    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
-    const globalLocation = globalThis?.location;
-    if (globalLocation && 'string' == typeof globalLocation.origin && globalLocation.origin) return globalLocation.origin;
-    return defaultOrigin;
-};
-const resolveTargetOrigin = (dataPlatform, defaultOrigin)=>{
-    const explicitTargetOrigin = (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.targetOrigin) || (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.endpointOrigin);
-    if (explicitTargetOrigin) return explicitTargetOrigin;
-    return defaultOrigin;
-};
-const shouldAttachEnvelopeHeader = (dataPlatform, defaultOrigin)=>{
-    if (true === dataPlatform.allowCrossOriginEnvelope) return true;
-    const currentOrigin = normalizeOrigin(resolveOrigin(defaultOrigin));
-    const targetOrigin = normalizeOrigin(resolveTargetOrigin(dataPlatform, defaultOrigin));
-    if (!currentOrigin || !targetOrigin) return true;
-    return currentOrigin === targetOrigin;
-};
-const toEnvelopeInput = (normalizedRequest)=>{
-    const payload = {};
-    if ((0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.params)) payload.path = normalizedRequest.params;
-    if ((0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.query)) payload.query = normalizedRequest.query;
-    if ('data' in normalizedRequest && void 0 !== normalizedRequest.data) payload.data = normalizedRequest.data;
-    if ('body' in normalizedRequest && void 0 !== normalizedRequest.body) payload.body = normalizedRequest.body;
-    if ("u" > typeof FormData && normalizedRequest.formData instanceof FormData) payload.formData = Array.from(normalizedRequest.formData.entries()).map(([key, value])=>[
-            key,
-            String(value)
-        ]);
-    if ("u" > typeof URLSearchParams && normalizedRequest.formUrlencoded instanceof URLSearchParams) payload.formUrlencoded = normalizedRequest.formUrlencoded.toString();
-    return payload;
-};
-const prepareEffectRequest = (options)=>{
-    const { endpoint, operation, request, config, createEffectRequestContext } = options;
-    const defaultOrigin = config.defaultOrigin;
-    const normalizedRequest = (0, external_request_context_js_namespaceObject.applyRequestContext)((0, external_request_js_namespaceObject.normalizeRequest)(endpoint.method, request), request, createEffectRequestContext);
-    const dataPlatform = (0, external_guards_js_namespaceObject.isRecord)(request) && (0, external_guards_js_namespaceObject.isRecord)(request.dataPlatform) ? request.dataPlatform : {};
-    const strictEnvelope = true === dataPlatform.requireEnvelope || true === dataPlatform.strict;
-    if (!strictEnvelope && !shouldAttachEnvelopeHeader(dataPlatform, defaultOrigin)) return normalizedRequest;
-    try {
-        const namespace = (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.appNamespace) || config.appNamespace;
-        const origin = (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.origin) || resolveOrigin(defaultOrigin);
-        const envelope = (0, index_js_namespaceObject.createRequestEnvelope)({
-            operation: {
-                ...operation,
-                appNamespace: namespace
-            },
-            scope: {
-                appNamespace: namespace,
-                origin,
-                tenantId: (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.tenantId),
-                userId: (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.userId),
-                sessionId: (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.sessionId)
-            },
-            requestInput: {
-                method: endpoint.method,
-                routePath: endpoint.routePath,
-                payload: toEnvelopeInput(normalizedRequest)
-            },
-            requestMode: isDataRequestMode(dataPlatform.requestMode) ? dataPlatform.requestMode : void 0,
-            mutationMode: isDataMutationMode(dataPlatform.mutationMode) ? dataPlatform.mutationMode : void 0,
-            selectionPlan: (0, external_guards_js_namespaceObject.isRecord)(dataPlatform.selectionPlan) ? dataPlatform.selectionPlan : void 0,
-            traceContext: (0, external_guards_js_namespaceObject.isRecord)(dataPlatform.traceContext) ? dataPlatform.traceContext : void 0,
-            requireTraceContext: true === dataPlatform.requireTraceContext
-        });
-        const headerName = (0, external_guards_js_namespaceObject.stringOrUndefined)(dataPlatform.envelopeHeader) || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
-        const headers = (0, external_guards_js_namespaceObject.isRecord)(normalizedRequest.headers) ? {
-            ...normalizedRequest.headers
-        } : {};
-        if (false === dataPlatform.batch) headers[index_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER] = 'off';
-        headers[headerName] = (0, index_js_namespaceObject.encodeRequestEnvelopeHeader)(envelope);
-        return {
-            ...normalizedRequest,
-            headers
-        };
-    } catch (error) {
-        if (strictEnvelope) throw error;
-        return normalizedRequest;
-    }
-};
-exports.prepareEffectRequest = __webpack_exports__.prepareEffectRequest;
-exports.resolveOrigin = __webpack_exports__.resolveOrigin;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "prepareEffectRequest",
-    "resolveOrigin"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});