@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/dist/cjs/workspaceEvents.js

@@ -0,0 +1,159 @@
+"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 ultramodernWorkspaceEventNames = {
+    navigate: 'ultramodern:navigate',
+    performanceSignal: 'ultramodern:performance-signal',
+    remoteReady: 'ultramodern:remote-ready',
+    routeSettled: 'ultramodern:route-settled'
+};
+class UltramodernWorkspaceEventValidationError {
+    constructor(eventName, payload){
+        this.name = 'UltramodernWorkspaceEventValidationError';
+        this.message = `Invalid payload for UltraModern workspace event "${eventName}"`;
+        this.eventName = eventName;
+        this.payload = payload;
+    }
+}
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isNonEmptyString = (value)=>'string' == typeof value && value.trim().length > 0;
+const isNonNegativeNumber = (value)=>'number' == typeof value && Number.isFinite(value) && value >= 0;
+const isUltramodernWorkspaceLocale = (value)=>'en' === value || 'cs' === value;
+const isPerformanceReadinessSignalId = (value)=>'bfcache' === value || 'core-web-vitals-rum' === value || 'duplicate-prefetch-warmup' === value || 'cache-policy-sanity' === value || 'save-data-behavior' === value || 'cloudflare-ssr-cache-hints' === value;
+const isPerformanceReadinessSignalStatus = (value)=>'pass' === value || 'warn' === value || 'fail' === value;
+const hasOptionalString = (value, key)=>void 0 === value[key] || isNonEmptyString(value[key]);
+const hasOptionalBoolean = (value, key)=>void 0 === value[key] || 'boolean' == typeof value[key];
+const hasOptionalRecord = (value, key)=>void 0 === value[key] || isRecord(value[key]);
+const hasOptionalNonNegativeNumber = (value, key)=>void 0 === value[key] || isNonNegativeNumber(value[key]);
+const hasOptionalLocale = (value, key)=>void 0 === value[key] || isUltramodernWorkspaceLocale(value[key]);
+const isUltramodernNavigatePayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.to) && hasOptionalBoolean(payload, 'replace') && hasOptionalRecord(payload, 'state');
+const isUltramodernRouteSettledPayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.pathname) && hasOptionalLocale(payload, 'locale') && hasOptionalString(payload, 'title');
+const isUltramodernRemoteReadyPayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.appId) && hasOptionalString(payload, 'build') && hasOptionalString(payload, 'surface') && hasOptionalString(payload, 'version');
+const isUltramodernPerformanceSignalPayload = (payload)=>isRecord(payload) && isPerformanceReadinessSignalId(payload.signalId) && isPerformanceReadinessSignalStatus(payload.status) && hasOptionalNonNegativeNumber(payload, 'durationMs') && hasOptionalRecord(payload, 'detail');
+const ultramodernWorkspaceEventValidators = {
+    [ultramodernWorkspaceEventNames.navigate]: isUltramodernNavigatePayload,
+    [ultramodernWorkspaceEventNames.performanceSignal]: isUltramodernPerformanceSignalPayload,
+    [ultramodernWorkspaceEventNames.remoteReady]: isUltramodernRemoteReadyPayload,
+    [ultramodernWorkspaceEventNames.routeSettled]: isUltramodernRouteSettledPayload
+};
+const isUltramodernWorkspaceEventPayload = (eventName, payload)=>ultramodernWorkspaceEventValidators[eventName](payload);
+const assertUltramodernWorkspaceEventPayload = (eventName, payload)=>{
+    if (!isUltramodernWorkspaceEventPayload(eventName, payload)) throw new UltramodernWorkspaceEventValidationError(eventName, payload);
+    return payload;
+};
+const createUltramodernWorkspaceEvent = (eventName, payload)=>new CustomEvent(eventName, {
+        bubbles: true,
+        composed: true,
+        detail: assertUltramodernWorkspaceEventPayload(eventName, payload)
+    });
+const dispatchUltramodernWorkspaceEvent = (target, eventName, payload)=>target.dispatchEvent(createUltramodernWorkspaceEvent(eventName, payload));
+const onUltramodernWorkspaceEvent = (target, eventName, handler)=>{
+    const listener = (event)=>{
+        if (!('detail' in event)) throw new UltramodernWorkspaceEventValidationError(eventName, void 0);
+        const customEvent = event;
+        handler(assertUltramodernWorkspaceEventPayload(eventName, customEvent.detail), customEvent);
+    };
+    target.addEventListener(eventName, listener);
+    return ()=>{
+        target.removeEventListener(eventName, listener);
+    };
+};
+const dispatchUltramodernNavigate = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.navigate, payload);
+const dispatchUltramodernRouteSettled = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.routeSettled, payload);
+const dispatchUltramodernRemoteReady = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.remoteReady, payload);
+const dispatchUltramodernPerformanceSignal = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.performanceSignal, payload);
+const onUltramodernNavigate = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.navigate, handler);
+const onUltramodernRouteSettled = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.routeSettled, handler);
+const onUltramodernRemoteReady = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.remoteReady, handler);
+const onUltramodernPerformanceSignal = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.performanceSignal, handler);
+__webpack_require__.d(__webpack_exports__, {
+    UltramodernWorkspaceEventValidationError: ()=>UltramodernWorkspaceEventValidationError
+}, {
+    assertUltramodernWorkspaceEventPayload: assertUltramodernWorkspaceEventPayload,
+    createUltramodernWorkspaceEvent: createUltramodernWorkspaceEvent,
+    dispatchUltramodernNavigate: dispatchUltramodernNavigate,
+    dispatchUltramodernPerformanceSignal: dispatchUltramodernPerformanceSignal,
+    dispatchUltramodernRemoteReady: dispatchUltramodernRemoteReady,
+    dispatchUltramodernRouteSettled: dispatchUltramodernRouteSettled,
+    dispatchUltramodernWorkspaceEvent: dispatchUltramodernWorkspaceEvent,
+    isUltramodernNavigatePayload: isUltramodernNavigatePayload,
+    isUltramodernPerformanceSignalPayload: isUltramodernPerformanceSignalPayload,
+    isUltramodernRemoteReadyPayload: isUltramodernRemoteReadyPayload,
+    isUltramodernRouteSettledPayload: isUltramodernRouteSettledPayload,
+    isUltramodernWorkspaceEventPayload: isUltramodernWorkspaceEventPayload,
+    onUltramodernNavigate: onUltramodernNavigate,
+    onUltramodernPerformanceSignal: onUltramodernPerformanceSignal,
+    onUltramodernRemoteReady: onUltramodernRemoteReady,
+    onUltramodernRouteSettled: onUltramodernRouteSettled,
+    onUltramodernWorkspaceEvent: onUltramodernWorkspaceEvent,
+    ultramodernWorkspaceEventNames: ultramodernWorkspaceEventNames
+});
+exports.UltramodernWorkspaceEventValidationError = __webpack_exports__.UltramodernWorkspaceEventValidationError;
+exports.assertUltramodernWorkspaceEventPayload = __webpack_exports__.assertUltramodernWorkspaceEventPayload;
+exports.createUltramodernWorkspaceEvent = __webpack_exports__.createUltramodernWorkspaceEvent;
+exports.dispatchUltramodernNavigate = __webpack_exports__.dispatchUltramodernNavigate;
+exports.dispatchUltramodernPerformanceSignal = __webpack_exports__.dispatchUltramodernPerformanceSignal;
+exports.dispatchUltramodernRemoteReady = __webpack_exports__.dispatchUltramodernRemoteReady;
+exports.dispatchUltramodernRouteSettled = __webpack_exports__.dispatchUltramodernRouteSettled;
+exports.dispatchUltramodernWorkspaceEvent = __webpack_exports__.dispatchUltramodernWorkspaceEvent;
+exports.isUltramodernNavigatePayload = __webpack_exports__.isUltramodernNavigatePayload;
+exports.isUltramodernPerformanceSignalPayload = __webpack_exports__.isUltramodernPerformanceSignalPayload;
+exports.isUltramodernRemoteReadyPayload = __webpack_exports__.isUltramodernRemoteReadyPayload;
+exports.isUltramodernRouteSettledPayload = __webpack_exports__.isUltramodernRouteSettledPayload;
+exports.isUltramodernWorkspaceEventPayload = __webpack_exports__.isUltramodernWorkspaceEventPayload;
+exports.onUltramodernNavigate = __webpack_exports__.onUltramodernNavigate;
+exports.onUltramodernPerformanceSignal = __webpack_exports__.onUltramodernPerformanceSignal;
+exports.onUltramodernRemoteReady = __webpack_exports__.onUltramodernRemoteReady;
+exports.onUltramodernRouteSettled = __webpack_exports__.onUltramodernRouteSettled;
+exports.onUltramodernWorkspaceEvent = __webpack_exports__.onUltramodernWorkspaceEvent;
+exports.ultramodernWorkspaceEventNames = __webpack_exports__.ultramodernWorkspaceEventNames;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "UltramodernWorkspaceEventValidationError",
+    "assertUltramodernWorkspaceEventPayload",
+    "createUltramodernWorkspaceEvent",
+    "dispatchUltramodernNavigate",
+    "dispatchUltramodernPerformanceSignal",
+    "dispatchUltramodernRemoteReady",
+    "dispatchUltramodernRouteSettled",
+    "dispatchUltramodernWorkspaceEvent",
+    "isUltramodernNavigatePayload",
+    "isUltramodernPerformanceSignalPayload",
+    "isUltramodernRemoteReadyPayload",
+    "isUltramodernRouteSettledPayload",
+    "isUltramodernWorkspaceEventPayload",
+    "onUltramodernNavigate",
+    "onUltramodernPerformanceSignal",
+    "onUltramodernRemoteReady",
+    "onUltramodernRouteSettled",
+    "onUltramodernWorkspaceEvent",
+    "ultramodernWorkspaceEventNames"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/buildIdentity.mjs

@@ -0,0 +1,35 @@
+function readBuildValue(read, fallback) {
+    try {
+        return read();
+    } catch (error) {
+        if (null !== error && 'object' == typeof error && 'name' in error && 'ReferenceError' === error.name) return fallback;
+        throw error;
+    }
+}
+function resolveUltramodernBuildArtifact(artifact, readers) {
+    const buildMarker = readers ? readBuildValue(readers.buildMarker, artifact.deliveryUnit.buildMarker) : artifact.deliveryUnit.buildMarker;
+    const sourceRevision = readers ? readBuildValue(readers.sourceRevision, artifact.deliveryUnit.sourceRevision) : artifact.deliveryUnit.sourceRevision;
+    const identity = {
+        build: buildMarker,
+        buildMarker,
+        sourceRevision
+    };
+    return {
+        ...artifact,
+        deliveryUnit: {
+            ...artifact.deliveryUnit,
+            ...identity
+        },
+        surfaces: {
+            api: {
+                ...artifact.surfaces.api,
+                ...identity
+            },
+            ui: {
+                ...artifact.surfaces.ui,
+                ...identity
+            }
+        }
+    };
+}
+export { resolveUltramodernBuildArtifact };

package/dist/esm/contextExtensions.mjs

@@ -0,0 +1,33 @@
+const EXTENSIONS_SLOT = Symbol.for('@modern-js/runtime:context-extensions');
+function getStore(context) {
+    return context[EXTENSIONS_SLOT];
+}
+function ensureStore(context) {
+    const target = context;
+    const store = target[EXTENSIONS_SLOT] ?? new Map();
+    Object.defineProperty(target, EXTENSIONS_SLOT, {
+        configurable: true,
+        enumerable: true,
+        value: store
+    });
+    return store;
+}
+function stripRuntimeContextExtensions(context) {
+    delete context[EXTENSIONS_SLOT];
+}
+function createRuntimeContextExtension(id) {
+    const key = Symbol.for(`@modern-js/runtime:context-extension:${id}`);
+    return {
+        key,
+        get (context) {
+            return getStore(context)?.get(key);
+        },
+        set (context, value) {
+            ensureStore(context).set(key, value);
+        },
+        remove (context) {
+            getStore(context)?.delete(key);
+        }
+    };
+}
+export { createRuntimeContextExtension, stripRuntimeContextExtensions };

package/dist/esm/headRuntime.mjs

@@ -0,0 +1,43 @@
+import { jsx } from "react/jsx-runtime";
+import react from "react";
+import { Helmet, HelmetProvider } from "react-helmet-async";
+import * as __rspack_external__rendererHead_mjs_b8160cc7 from "./rendererHead.mjs";
+function createHeadRuntime() {
+    const HeadContext = /*#__PURE__*/ react.createContext(void 0);
+    const collectServerHelmet = ({ runtimeContext, helmetContext }, props)=>{
+        const createRecord = ()=>__rspack_external__rendererHead_mjs_b8160cc7.createHelmetRecord(react, props);
+        const deriveState = (records)=>__rspack_external__rendererHead_mjs_b8160cc7.deriveHelmetServerState(react, records);
+        const marker = __rspack_external__rendererHead_mjs_b8160cc7.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
+        if (void 0 !== marker) return marker;
+        helmetContext.helmet = __rspack_external__rendererHead_mjs_b8160cc7.collectImmediateHelmetState(react, helmetContext, createRecord());
+    };
+    const Head = (props)=>{
+        const state = react.useContext(HeadContext);
+        if (void 0 !== state) return __rspack_external__rendererHead_mjs_b8160cc7.renderHeadMarker(react, collectServerHelmet(state, props));
+        return /*#__PURE__*/ react.createElement(Helmet, props);
+    };
+    const ClientRoot = ({ children })=>{
+        const state = react.useContext(HeadContext);
+        return void 0 === state ? /*#__PURE__*/ jsx(HelmetProvider, {
+            children: children
+        }) : children;
+    };
+    return {
+        Head,
+        wrapServerRoot (root, state) {
+            return /*#__PURE__*/ jsx(HeadContext.Provider, {
+                value: state,
+                children: /*#__PURE__*/ jsx(HelmetProvider, {
+                    context: state.helmetContext,
+                    children: root
+                })
+            });
+        },
+        wrapClientRoot (root) {
+            return /*#__PURE__*/ jsx(ClientRoot, {
+                children: root
+            });
+        }
+    };
+}
+export { createHeadRuntime };

package/dist/esm/helmetContext.mjs

@@ -0,0 +1,13 @@
+import { createRuntimeContextExtension } from "./contextExtensions.mjs";
+const helmetContextExtension = createRuntimeContextExtension('@modern-js/runtime:helmet-context');
+function getHelmetContext(context) {
+    return helmetContextExtension.get(context);
+}
+function ensureHelmetContext(context) {
+    const existing = helmetContextExtension.get(context);
+    if (void 0 !== existing) return existing;
+    const created = {};
+    helmetContextExtension.set(context, created);
+    return created;
+}
+export { ensureHelmetContext, getHelmetContext };

package/dist/esm/index.mjs

@@ -1,4 +1,6 @@
 export * from "./html.mjs";
 export * from "./navigationWarmup.mjs";
+export * from "./prefetchPolicy.mjs";
 export * from "./rendererHead.mjs";
+export * from "./routeHydration.mjs";
 export * from "./shellStream.mjs";

package/dist/esm/localisedLoaderIdentity.mjs

@@ -0,0 +1,13 @@
+function resolveLocalisedLoaderRouteId(routes, requestedId, matchedIds = []) {
+    if (matchedIds.includes(requestedId)) return requestedId;
+    const matched = new Set(matchedIds);
+    const visit = (nodes)=>{
+        for (const route of nodes){
+            if (route.id && matched.has(route.id) && route.modernLocalisedRoute?.id === requestedId) return route.id;
+            const child = route.children && visit(route.children);
+            if (child) return child;
+        }
+    };
+    return visit(routes) ?? requestedId;
+}
+export { resolveLocalisedLoaderRouteId };

package/dist/esm/prefetchPolicy.mjs

@@ -0,0 +1,11 @@
+function resolvePreloadFromPrefetch(prefetch, preload) {
+    if (void 0 !== preload) return preload;
+    if ('none' === prefetch) return false;
+    if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
+    return 'viewport';
+}
+function normalizePreloadBehavior(preload, prefetch) {
+    const resolved = resolvePreloadFromPrefetch(prefetch, preload);
+    return false === resolved ? 'none' : resolved;
+}
+export { normalizePreloadBehavior, resolvePreloadFromPrefetch };

package/dist/esm/reactContext.mjs

@@ -0,0 +1,7 @@
+function getRuntimeReactContext(kind, create) {
+    const key = Symbol.for(`@modern-js/runtime:react-context:v1:${kind}`);
+    const contexts = globalThis;
+    contexts[key] ??= create();
+    return contexts[key];
+}
+export { getRuntimeReactContext };

package/dist/esm/request-policy/browser.mjs

@@ -0,0 +1,11 @@
+import { createClient } from "@modern-js/create-request/client";
+import { createPolicyClient } from "./client.mjs";
+export * from "./requestContext.mjs";
+export * from "./types.mjs";
+const browser_createClient = ()=>createPolicyClient(createClient(), {
+        target: 'browser',
+        resolveSourceOrigin: ()=>"u" > typeof window ? window.location.origin : void 0
+    });
+const { configure: configure, createRequest: createRequest, createUploader: createUploader } = browser_createClient();
+export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError } from "./policyCore.mjs";
+export { browser_createClient as createClient, configure, createRequest, createUploader };

package/dist/esm/request-policy/client.mjs

@@ -0,0 +1,195 @@
+import { IdentityBindingViolationError, ProducerDomainNotConfiguredError, TRACEPARENT_HEADER, attachOperationContextHeaders, buildEnvelopeHeaderValue, deleteHeader, firstHeaderValue, isEmptyDomain, isSecuredRequestId, parseTraceparentValue, readHeader, resolveConfiguredRequest, toOrigin, writeHeader } from "./policyCore.mjs";
+import { executeWithResilience } from "./transport.mjs";
+import { BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS, BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER } from "./types.mjs";
+const createPolicyClient = (nativeClient, environment)=>{
+    const isServerTarget = 'server' === environment.target;
+    const configuredRequests = new Map();
+    const realResolveHeaders = new Map();
+    const realRequireEnvelope = new Map();
+    const realAllowCrossOriginEnvelope = new Map();
+    const realTransportResilience = new Map();
+    const realIdentityBinding = new Map();
+    const realOperationContract = new Map();
+    const domainMap = new Map();
+    const attachEnvelopeHeaderIfRequired = (headers, requestId, url, incomingHeaders)=>{
+        const shouldRequireEnvelope = realRequireEnvelope.get(requestId) ?? isSecuredRequestId(requestId);
+        if (!shouldRequireEnvelope) return;
+        headers[BFF_ENVELOPE_HEADER] = buildEnvelopeHeaderValue({
+            requestId,
+            target: environment.target,
+            sourceOrigin: environment.resolveSourceOrigin(incomingHeaders),
+            targetOrigin: toOrigin(url),
+            traceContext: parseTraceparentValue(readHeader(headers, TRACEPARENT_HEADER)),
+            allowCrossOriginEnvelope: realAllowCrossOriginEnvelope.get(requestId)
+        });
+    };
+    const attachSecuredOperationHeaders = (headers, requestId, method, path, operationContext)=>{
+        if (!isSecuredRequestId(requestId)) return;
+        attachOperationContextHeaders({
+            headers,
+            requestId,
+            target: environment.target,
+            method,
+            path,
+            operationContext,
+            operationContract: realOperationContract.get(requestId),
+            operationContextHeader: BFF_OPERATION_CONTEXT_HEADER,
+            operationContextDetailHeader: BFF_OPERATION_CONTEXT_DETAIL_HEADER
+        });
+    };
+    const applyIdentityAndForwardedHeaders = ({ headers, requestId, incomingHeaders, forwardedHeaders, allowedHeaders: targetAllowedHeaders })=>{
+        const identityBinding = realIdentityBinding.get(requestId);
+        const identityBindingEnabled = identityBinding?.enabled ?? isSecuredRequestId(requestId);
+        const identityBindingStrict = identityBinding?.strict ?? isSecuredRequestId(requestId);
+        const protectedIdentityHeaders = (identityBinding?.protectedHeaders || BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS).map((header)=>header.toLowerCase());
+        if (identityBindingEnabled) {
+            const derivedIdentityHeaders = {};
+            if (isServerTarget) for (const header of protectedIdentityHeaders){
+                const incomingHeaderValue = readHeader(incomingHeaders, header);
+                if (void 0 !== incomingHeaderValue) writeHeader(derivedIdentityHeaders, header, incomingHeaderValue);
+            }
+            const customDerivedHeaders = identityBinding?.deriveHeaders?.({
+                requestId,
+                target: environment.target,
+                incomingHeaders: isServerTarget ? {
+                    ...incomingHeaders
+                } : {},
+                protectedHeaders: [
+                    ...protectedIdentityHeaders
+                ]
+            });
+            if (customDerivedHeaders && 'object' == typeof customDerivedHeaders) for (const header of protectedIdentityHeaders){
+                const customValue = readHeader(customDerivedHeaders, header);
+                if (void 0 !== customValue) writeHeader(derivedIdentityHeaders, header, customValue);
+            }
+            for (const header of protectedIdentityHeaders){
+                const attemptedValue = readHeader(headers, header);
+                if (void 0 === attemptedValue) continue;
+                const violation = {
+                    requestId,
+                    target: environment.target,
+                    header,
+                    attemptedValue,
+                    derivedValue: readHeader(derivedIdentityHeaders, header),
+                    reason: 'client_override_blocked'
+                };
+                identityBinding?.onViolation?.(violation);
+                if (identityBindingStrict) throw new IdentityBindingViolationError(violation);
+                deleteHeader(headers, header);
+            }
+            Object.keys(derivedIdentityHeaders).forEach((header)=>{
+                isServerTarget ? writeHeader(forwardedHeaders, header, derivedIdentityHeaders[header]) : writeHeader(headers, header, derivedIdentityHeaders[header]);
+            });
+        }
+        if (isServerTarget) {
+            const resolveHeaders = realResolveHeaders.get(requestId);
+            if (resolveHeaders) {
+                const resolvedHeaders = resolveHeaders({
+                    requestId,
+                    allowedHeaders: targetAllowedHeaders,
+                    incomingHeaders: {
+                        ...forwardedHeaders
+                    }
+                });
+                if (resolvedHeaders && 'object' == typeof resolvedHeaders) for (const key of targetAllowedHeaders){
+                    const resolvedValue = readHeader(resolvedHeaders, key);
+                    if (void 0 !== resolvedValue) {
+                        if (identityBindingEnabled && protectedIdentityHeaders.includes(key.toLowerCase())) {
+                            writeHeader(forwardedHeaders, key.toLowerCase(), resolvedValue);
+                            continue;
+                        }
+                        writeHeader(forwardedHeaders, key, resolvedValue);
+                    }
+                }
+            }
+        }
+        return headers;
+    };
+    const configure = (options)=>{
+        const { request, interceptor, allowedHeaders, resolveHeaders, transport, requireEnvelope, allowCrossOriginEnvelope, identityBinding, operationContract, setDomain, requestId = 'default' } = options;
+        const hasExistingDomain = domainMap.has(requestId);
+        if ('default' !== requestId && !setDomain && !hasExistingDomain) throw new ProducerDomainNotConfiguredError(requestId);
+        let resolvedDomain;
+        nativeClient.configure({
+            request,
+            interceptor,
+            allowedHeaders,
+            requestId,
+            setDomain: setDomain ? (options)=>{
+                resolvedDomain = setDomain(options);
+                if ('default' !== requestId && isEmptyDomain(resolvedDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+                return resolvedDomain;
+            } : void 0
+        });
+        realResolveHeaders.delete(requestId);
+        realTransportResilience.delete(requestId);
+        realIdentityBinding.delete(requestId);
+        realOperationContract.delete(requestId);
+        realRequireEnvelope.delete(requestId);
+        realAllowCrossOriginEnvelope.delete(requestId);
+        if (isServerTarget && 'function' == typeof resolveHeaders) realResolveHeaders.set(requestId, resolveHeaders);
+        if (transport && 'object' == typeof transport) realTransportResilience.set(requestId, transport);
+        if (identityBinding && 'object' == typeof identityBinding) realIdentityBinding.set(requestId, identityBinding);
+        if (operationContract && 'object' == typeof operationContract) realOperationContract.set(requestId, operationContract);
+        if ('boolean' == typeof requireEnvelope) realRequireEnvelope.set(requestId, requireEnvelope);
+        if ('boolean' == typeof allowCrossOriginEnvelope || 'function' == typeof allowCrossOriginEnvelope) realAllowCrossOriginEnvelope.set(requestId, allowCrossOriginEnvelope);
+        if ('string' == typeof resolvedDomain) domainMap.set(requestId, resolvedDomain);
+        configuredRequests.set(requestId, true);
+    };
+    const createHooks = (path, method, requestId, operationContext, upload = false)=>({
+            onStart: ({ configuredDomain })=>{
+                resolveConfiguredRequest(configuredRequests, requestId, false);
+                if (!upload && 'default' !== requestId && isEmptyDomain(configuredDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+            },
+            prepareHeaders: applyIdentityAndForwardedHeaders,
+            dispatch: (context)=>{
+                const { incomingHeaders, url, init: { headers } } = context;
+                if (isServerTarget && !upload) {
+                    if (void 0 === readHeader(headers, TRACEPARENT_HEADER)) {
+                        const incomingTraceparent = firstHeaderValue(readHeader(incomingHeaders, TRACEPARENT_HEADER));
+                        if ('string' == typeof incomingTraceparent) writeHeader(headers, TRACEPARENT_HEADER, incomingTraceparent);
+                    }
+                    if (void 0 === readHeader(headers, TRACEPARENT_HEADER) && operationContext?.traceparent) writeHeader(headers, TRACEPARENT_HEADER, operationContext.traceparent);
+                }
+                attachEnvelopeHeaderIfRequired(headers, requestId, url, incomingHeaders);
+                attachSecuredOperationHeaders(headers, requestId, method, path, operationContext);
+                return executeWithResilience({
+                    requestId,
+                    target: environment.target,
+                    method,
+                    url,
+                    init: context.init,
+                    fetcher: context.fetcher,
+                    transport: realTransportResilience.get(requestId)
+                });
+            }
+        });
+    const createRequest = (...args)=>{
+        const options = 'object' == typeof args[0] && null !== args[0] ? args[0] : {
+            path: args[0],
+            method: args[1],
+            port: args[2],
+            httpMethodDecider: args[3],
+            fetch: args[4],
+            requestId: args[5],
+            operationContext: args[6]
+        };
+        const { operationContext, requestId = 'default', ...nativeOptions } = options;
+        return nativeClient.createRequest({
+            ...nativeOptions,
+            requestId,
+            hooks: createHooks(options.path, options.method, requestId, operationContext)
+        });
+    };
+    const createUploader = ({ operationContext, requestId = 'default', ...options })=>nativeClient.createUploader({
+            ...options,
+            requestId,
+            hooks: createHooks(options.path, 'POST', requestId, operationContext, true)
+        });
+    return {
+        configure,
+        createRequest,
+        createUploader
+    };
+};
+export { createPolicyClient };