@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.6 → 3.5.0-ultramodern.75

package/dist/cjs/runtime/effect/index.js

@@ -1,5 +1,11 @@
 "use strict";
 var __webpack_modules__ = {
+    "./backend-federation-manifest" (module) {
+        module.exports = require("./backend-federation-manifest.js");
+    },
+    "./backend-federation" (module) {
+        module.exports = require("./backend-federation.js");
+    },
     "./context" (module) {
         module.exports = require("./context.js");
     },
@@ -61,47 +67,117 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     var _effect_opentelemetry__rspack_import_0 = __webpack_require__("@effect/opentelemetry");
-    var _context__rspack_import_1 = __webpack_require__("./context");
-    var _edge__rspack_import_2 = __webpack_require__("./edge");
-    var _handler__rspack_import_3 = __webpack_require__("./handler");
+    var _backend_federation__rspack_import_1 = __webpack_require__("./backend-federation");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _handler__rspack_import_3)if ([
+    for(const __rspack_import_key in _backend_federation__rspack_import_1)if ([
+        "createBackendFederationLoadEntryPlugin",
+        "createEffectOperationContext",
+        "BACKEND_FEDERATION_MANIFEST_FILE",
+        "useOperationContext",
+        "loadBackendFederatedEffectApi",
+        "BACKEND_FEDERATION_CONTRACT_VERSION",
+        "OpenTelemetry",
+        "loadBackendFederatedEffectApiFromManifest",
+        "createEffectBffEdgeHandler",
+        "BackendFederationManifestAdapterError",
+        "resolveBackendFederationRemoteFromManifest",
+        "BACKEND_FEDERATION_EFFECT_EXPOSE",
         "runWithEffectContext",
         "useEffectContext",
+        "loadBackendFederationManifest",
+        "dispatchEffectBffRequest",
         "default",
-        "useOperationContext",
+        "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
+        "createEffectBffTestHandler",
+        "createBackendFederationRuntime"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_backend_federation__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _backend_federation_manifest__rspack_import_2 = __webpack_require__("./backend-federation-manifest");
+    var _context__rspack_import_3 = __webpack_require__("./context");
+    var _edge__rspack_import_4 = __webpack_require__("./edge");
+    var _handler__rspack_import_5 = __webpack_require__("./handler");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _handler__rspack_import_5)if ([
+        "createBackendFederationLoadEntryPlugin",
         "createEffectOperationContext",
+        "BACKEND_FEDERATION_MANIFEST_FILE",
+        "useOperationContext",
+        "loadBackendFederatedEffectApi",
+        "BACKEND_FEDERATION_CONTRACT_VERSION",
+        "OpenTelemetry",
+        "loadBackendFederatedEffectApiFromManifest",
+        "createEffectBffEdgeHandler",
+        "BackendFederationManifestAdapterError",
+        "resolveBackendFederationRemoteFromManifest",
+        "BACKEND_FEDERATION_EFFECT_EXPOSE",
+        "runWithEffectContext",
+        "useEffectContext",
+        "loadBackendFederationManifest",
         "dispatchEffectBffRequest",
+        "default",
+        "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
         "createEffectBffTestHandler",
-        "OpenTelemetry",
-        "createEffectBffEdgeHandler"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_3[__rspack_import_key];
+        "createBackendFederationRuntime"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_handler__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
     __webpack_require__.d(__webpack_exports__, {
+        BACKEND_FEDERATION_CONTRACT_VERSION: ()=>_backend_federation__rspack_import_1.BACKEND_FEDERATION_CONTRACT_VERSION,
+        BACKEND_FEDERATION_EFFECT_EXPOSE: ()=>_backend_federation__rspack_import_1.BACKEND_FEDERATION_EFFECT_EXPOSE,
+        BACKEND_FEDERATION_MANIFEST_FILE: ()=>_backend_federation__rspack_import_1.BACKEND_FEDERATION_MANIFEST_FILE,
+        BACKEND_FEDERATION_NODE_ADAPTER_VERSION: ()=>_backend_federation__rspack_import_1.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        BackendFederationManifestAdapterError: ()=>_backend_federation_manifest__rspack_import_2.BackendFederationManifestAdapterError,
         OpenTelemetry: ()=>_effect_opentelemetry__rspack_import_0,
-        createEffectBffEdgeHandler: ()=>_edge__rspack_import_2.createEffectBffEdgeHandler,
-        createEffectBffTestHandler: ()=>_edge__rspack_import_2.createEffectBffTestHandler,
-        createEffectOperationContext: ()=>_context__rspack_import_1.createEffectOperationContext,
-        dispatchEffectBffRequest: ()=>_edge__rspack_import_2.dispatchEffectBffRequest,
-        runWithEffectContext: ()=>_context__rspack_import_1.runWithEffectContext,
-        useEffectContext: ()=>_context__rspack_import_1.useEffectContext,
-        useOperationContext: ()=>_context__rspack_import_1.useOperationContext
+        createBackendFederationLoadEntryPlugin: ()=>_backend_federation__rspack_import_1.createBackendFederationLoadEntryPlugin,
+        createBackendFederationRuntime: ()=>_backend_federation__rspack_import_1.createBackendFederationRuntime,
+        createEffectBffEdgeHandler: ()=>_edge__rspack_import_4.createEffectBffEdgeHandler,
+        createEffectBffTestHandler: ()=>_edge__rspack_import_4.createEffectBffTestHandler,
+        createEffectOperationContext: ()=>_context__rspack_import_3.createEffectOperationContext,
+        dispatchEffectBffRequest: ()=>_edge__rspack_import_4.dispatchEffectBffRequest,
+        loadBackendFederatedEffectApi: ()=>_backend_federation__rspack_import_1.loadBackendFederatedEffectApi,
+        loadBackendFederatedEffectApiFromManifest: ()=>_backend_federation_manifest__rspack_import_2.loadBackendFederatedEffectApiFromManifest,
+        loadBackendFederationManifest: ()=>_backend_federation_manifest__rspack_import_2.loadBackendFederationManifest,
+        resolveBackendFederationRemoteFromManifest: ()=>_backend_federation_manifest__rspack_import_2.resolveBackendFederationRemoteFromManifest,
+        runWithEffectContext: ()=>_context__rspack_import_3.runWithEffectContext,
+        useEffectContext: ()=>_context__rspack_import_3.useEffectContext,
+        useOperationContext: ()=>_context__rspack_import_3.useOperationContext
     });
 })();
+exports.BACKEND_FEDERATION_CONTRACT_VERSION = __webpack_exports__.BACKEND_FEDERATION_CONTRACT_VERSION;
+exports.BACKEND_FEDERATION_EFFECT_EXPOSE = __webpack_exports__.BACKEND_FEDERATION_EFFECT_EXPOSE;
+exports.BACKEND_FEDERATION_MANIFEST_FILE = __webpack_exports__.BACKEND_FEDERATION_MANIFEST_FILE;
+exports.BACKEND_FEDERATION_NODE_ADAPTER_VERSION = __webpack_exports__.BACKEND_FEDERATION_NODE_ADAPTER_VERSION;
+exports.BackendFederationManifestAdapterError = __webpack_exports__.BackendFederationManifestAdapterError;
 exports.OpenTelemetry = __webpack_exports__.OpenTelemetry;
+exports.createBackendFederationLoadEntryPlugin = __webpack_exports__.createBackendFederationLoadEntryPlugin;
+exports.createBackendFederationRuntime = __webpack_exports__.createBackendFederationRuntime;
 exports.createEffectBffEdgeHandler = __webpack_exports__.createEffectBffEdgeHandler;
 exports.createEffectBffTestHandler = __webpack_exports__.createEffectBffTestHandler;
 exports.createEffectOperationContext = __webpack_exports__.createEffectOperationContext;
 exports.dispatchEffectBffRequest = __webpack_exports__.dispatchEffectBffRequest;
+exports.loadBackendFederatedEffectApi = __webpack_exports__.loadBackendFederatedEffectApi;
+exports.loadBackendFederatedEffectApiFromManifest = __webpack_exports__.loadBackendFederatedEffectApiFromManifest;
+exports.loadBackendFederationManifest = __webpack_exports__.loadBackendFederationManifest;
+exports.resolveBackendFederationRemoteFromManifest = __webpack_exports__.resolveBackendFederationRemoteFromManifest;
 exports.runWithEffectContext = __webpack_exports__.runWithEffectContext;
 exports.useEffectContext = __webpack_exports__.useEffectContext;
 exports.useOperationContext = __webpack_exports__.useOperationContext;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BACKEND_FEDERATION_CONTRACT_VERSION",
+    "BACKEND_FEDERATION_EFFECT_EXPOSE",
+    "BACKEND_FEDERATION_MANIFEST_FILE",
+    "BACKEND_FEDERATION_NODE_ADAPTER_VERSION",
+    "BackendFederationManifestAdapterError",
     "OpenTelemetry",
+    "createBackendFederationLoadEntryPlugin",
+    "createBackendFederationRuntime",
     "createEffectBffEdgeHandler",
     "createEffectBffTestHandler",
     "createEffectOperationContext",
     "dispatchEffectBffRequest",
+    "loadBackendFederatedEffectApi",
+    "loadBackendFederatedEffectApiFromManifest",
+    "loadBackendFederationManifest",
+    "resolveBackendFederationRemoteFromManifest",
     "runWithEffectContext",
     "useEffectContext",
     "useOperationContext"

package/dist/cjs/runtime/effect/module.js

@@ -32,26 +32,17 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const Context_namespaceObject = require("effect/Context");
 const httpapi_namespaceObject = require("effect/unstable/httpapi");
+const external_entry_shape_js_namespaceObject = require("./entry-shape.js");
 const external_handler_js_namespaceObject = require("./handler.js");
-function isRecord(value) {
-    return 'object' == typeof value && null !== value;
-}
-function includesRuntimeExports(value) {
-    return 'api' in value || 'layer' in value || 'createHandler' in value || 'handler' in value;
-}
 function isRequestHandler(value) {
     return 'function' == typeof value;
 }
-function isEffectApiDefinition(module) {
-    return httpapi_namespaceObject.HttpApi.isHttpApi(module.api) && void 0 !== module.layer;
-}
 function isEffectServiceContext(context) {
     return 'object' == typeof context && null !== context && 'mapUnsafe' in context;
 }
 const emptyEffectServiceContext = Context_namespaceObject.empty();
-const strictEffectApproachMessage = '[BFF][Effect] strictEffectApproach is enforced: Effect API entries must export defineEffectBff(...) or a { api, layer } HttpApi module. Raw handler exports, default request handlers, and unbranded custom createHandler factories are not valid Effect API entries.';
 function rejectLegacyEffectModuleShape(options, shape) {
-    options.onWarning?.(`${strictEffectApproachMessage} Rejected ${shape}.`);
+    options.onWarning?.(`${external_entry_shape_js_namespaceObject.strictEffectApproachMessage} Rejected ${shape}.`);
     return true;
 }
 function callEffectBffRequestHandler(handler, request, context) {
@@ -72,41 +63,21 @@ function createLoadedHttpApiHandler(webHandler) {
         dispose: webHandler.dispose
     };
 }
-function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
-    if (isRequestHandler(normalizedModule.handler)) {
-        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return null;
-        return {
-            handler: normalizedModule.handler
-        };
-    }
-    const entry = normalizedModule.default;
-    if (isRequestHandler(entry)) {
-        if (rejectLegacyEffectModuleShape(options, 'default request handler')) return null;
-        return {
-            handler: entry
-        };
-    }
-    if (isRecord(entry)) normalizedModule = {
-        ...normalizedModule,
-        ...entry
-    };
-    if (isRecord(entry) && 'handler' in entry) {
-        const maybeHandler = entry.handler;
-        if (isRequestHandler(maybeHandler)) normalizedModule = {
-            ...normalizedModule,
-            handler: maybeHandler
-        };
-    }
-    if (isRequestHandler(normalizedModule.handler)) {
-        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return null;
-        return {
-            handler: normalizedModule.handler
-        };
+function classifyEffectBffRuntimeEntryShape(module) {
+    return (0, external_entry_shape_js_namespaceObject.classifyEffectBffEntryModule)(module, {
+        isRequestHandler,
+        isValidatorAwareHandlerFactory: external_entry_shape_js_namespaceObject.isValidatorAwareHandlerFactory,
+        isHttpApi: httpapi_namespaceObject.HttpApi.isHttpApi
+    });
+}
+function resolveClassifiedEffectBffModuleHandler(facts, options = {}) {
+    if (!facts) return null;
+    if (facts.legacyShape) {
+        if (rejectLegacyEffectModuleShape(options, facts.legacyShape)) return null;
     }
-    if ('function' == typeof normalizedModule.createHandler) {
-        const factory = normalizedModule.createHandler;
-        const validatorAware = (0, external_handler_js_namespaceObject.isValidatorAwareHandlerFactory)(factory);
-        if (!validatorAware && rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export')) return null;
+    if ('function' == typeof facts.createHandler) {
+        if (!facts.createHandlerValidatorAware && rejectLegacyEffectModuleShape(options, 'unbranded `createHandler` export')) return null;
+        const factory = facts.createHandler;
         const webHandler = factory({
             openapi: options.openapi,
             dataPlatform: options.dataPlatform,
@@ -114,11 +85,11 @@ function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {})
         });
         return createLoadedHandler(webHandler);
     }
-    if (isEffectApiDefinition(normalizedModule)) {
+    if (void 0 !== facts.api && facts.hasRuntimeLayer) {
         options.onWarning?.('[BFF][Effect] Detected { api, layer } export without createHandler. Prefer `defineEffectBff(...)` from @modern-js/plugin-bff/server to avoid module instance mismatch.');
         const webHandler = (0, external_handler_js_namespaceObject.createHttpApiHandler)({
-            api: normalizedModule.api,
-            layer: normalizedModule.layer,
+            api: facts.api,
+            layer: facts.layer,
             openapi: options.openapi,
             dataPlatform: options.dataPlatform,
             validateRequest: options.validateRequest
@@ -127,39 +98,11 @@ function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {})
     }
     return null;
 }
+function resolveNormalizedEffectBffModuleHandler(normalizedModule, options = {}) {
+    return resolveClassifiedEffectBffModuleHandler(classifyEffectBffRuntimeEntryShape(normalizedModule), options);
+}
 function resolveEffectBffModuleHandler(mod, options = {}) {
-    let normalizedModule = mod;
-    const mergeRuntimeExports = (value)=>{
-        if (!isRecord(value) || !includesRuntimeExports(value)) return;
-        normalizedModule = {
-            ...normalizedModule,
-            ...value
-        };
-    };
-    if (isRequestHandler(normalizedModule.handler)) {
-        if (rejectLegacyEffectModuleShape(options, '`handler` export')) return Promise.resolve(null);
-        return Promise.resolve({
-            handler: normalizedModule.handler
-        });
-    }
-    const entry = normalizedModule.default;
-    if (isRequestHandler(entry)) {
-        if (rejectLegacyEffectModuleShape(options, 'default request handler')) return Promise.resolve(null);
-        return Promise.resolve({
-            handler: entry
-        });
-    }
-    if ('function' == typeof entry && 0 === entry.length) return Promise.resolve(entry()).then((out)=>{
-        if (isRequestHandler(out)) {
-            if (rejectLegacyEffectModuleShape(options, 'default factory returning a request handler')) return null;
-            return {
-                handler: out
-            };
-        }
-        mergeRuntimeExports(out);
-        return resolveNormalizedEffectBffModuleHandler(normalizedModule, options);
-    });
-    return Promise.resolve(resolveNormalizedEffectBffModuleHandler(normalizedModule, options));
+    return Promise.resolve(resolveNormalizedEffectBffModuleHandler(mod, options));
 }
 exports.resolveEffectBffModuleHandler = __webpack_exports__.resolveEffectBffModuleHandler;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/runtime/effect/rpcSerialization.js

@@ -0,0 +1,54 @@
+"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__, {
+    getRpcSerializationLayer: ()=>getRpcSerializationLayer
+});
+const rpc_namespaceObject = require("effect/unstable/rpc");
+function getRpcSerializationLayer(serialization) {
+    switch(serialization){
+        case 'ndjson':
+            return rpc_namespaceObject.RpcSerialization.layerNdjson;
+        case 'jsonRpc':
+            return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
+        case 'ndJsonRpc':
+            return rpc_namespaceObject.RpcSerialization.layerNdJsonRpc();
+        case 'msgPack':
+            return rpc_namespaceObject.RpcSerialization.layerMsgPack;
+        default:
+            return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
+    }
+}
+exports.getRpcSerializationLayer = __webpack_exports__.getRpcSerializationLayer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getRpcSerializationLayer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,73 @@
+"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/runtime/effect-client/envelope.js

@@ -0,0 +1,145 @@
+"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
+});

package/dist/cjs/runtime/effect-client/guards.js

@@ -0,0 +1,44 @@
+"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__);
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const stringOrUndefined = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+__webpack_require__.d(__webpack_exports__, {}, {
+    isRecord: isRecord,
+    stringOrUndefined: stringOrUndefined
+});
+exports.isRecord = __webpack_exports__.isRecord;
+exports.stringOrUndefined = __webpack_exports__.stringOrUndefined;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isRecord",
+    "stringOrUndefined"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect-client/index.js

@@ -60,6 +60,7 @@ const Scope_namespaceObject = require("effect/Scope");
 const http_namespaceObject = require("effect/unstable/http");
 const httpapi_namespaceObject = require("effect/unstable/httpapi");
 const rpc_namespaceObject = require("effect/unstable/rpc");
+const rpcSerialization_js_namespaceObject = require("../effect/rpcSerialization.js");
 const Schema_namespaceObject = require("effect/Schema");
 const HttpClientError_namespaceObject = require("effect/unstable/http/HttpClientError");
 class EffectRpcClientError extends Data_namespaceObject.TaggedError('EffectRpcClientError') {
@@ -72,7 +73,10 @@ function applySelection(value, selection) {
     if (Array.isArray(value)) return value.map((item)=>applySelection(item, selection));
     if (!isRecord(value) || !isRecord(selection)) return value;
     const masked = {};
-    for (const key of Object.keys(selection))if (key in value) masked[key] = applySelection(value[key], selection[key]);
+    for (const key of Object.keys(selection)){
+        const selected = selection[key];
+        if (void 0 !== selected && key in value && (true === selected || isRecord(selected))) masked[key] = applySelection(value[key], selected);
+    }
     return masked;
 }
 function view() {
@@ -86,20 +90,6 @@ function runEffectView(request, selection) {
         request.then((value)=>resolve(mask(value, selection)), (reason)=>reject(reason));
     });
 }
-function getRpcSerializationLayer(serialization) {
-    switch(serialization){
-        case 'ndjson':
-            return rpc_namespaceObject.RpcSerialization.layerNdjson;
-        case 'jsonRpc':
-            return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
-        case 'ndJsonRpc':
-            return rpc_namespaceObject.RpcSerialization.layerNdJsonRpc();
-        case 'msgPack':
-            return rpc_namespaceObject.RpcSerialization.layerMsgPack;
-        default:
-            return rpc_namespaceObject.RpcSerialization.layerJsonRpc();
-    }
-}
 function makeEffectHttpApiClient(api, options) {
     const requestContextHeaders = (0, create_request_namespaceObject.createRequestContextHeaders)(options?.requestContext);
     const transformClient = (client)=>{
@@ -119,7 +109,7 @@ function makeEffectHttpApiClient(api, options) {
 function makeEffectRpcClient(group, options) {
     const protocolLayer = Layer_namespaceObject.provide(rpc_namespaceObject.RpcClient.layerProtocolHttp({
         url: options.url
-    }), Layer_namespaceObject.mergeAll(getRpcSerializationLayer(options.serialization), http_namespaceObject.FetchHttpClient.layer));
+    }), Layer_namespaceObject.mergeAll((0, rpcSerialization_js_namespaceObject.getRpcSerializationLayer)(options.serialization), http_namespaceObject.FetchHttpClient.layer));
     const middlewareLayer = options.middlewareLayer ?? Layer_namespaceObject.empty;
     const runtimeLayer = Layer_namespaceObject.mergeAll(protocolLayer, middlewareLayer);
     return Effect_namespaceObject.tryPromise({