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

package/dist/cjs/runtimeContextProjection.js

@@ -0,0 +1,112 @@
+"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__, {
+    projectRuntimeContext: ()=>projectRuntimeContext
+});
+const external_contextExtensions_js_namespaceObject = require("./contextExtensions.js");
+function createRscSafeRequestContext(ssrContext) {
+    const requestContext = {
+        request: {
+            params: {},
+            pathname: '',
+            query: {},
+            headers: {},
+            host: '',
+            url: ''
+        },
+        response: {
+            setHeader () {},
+            status () {},
+            locals: {}
+        }
+    };
+    Object.defineProperty(requestContext.response, 'setHeader', {
+        enumerable: false
+    });
+    Object.defineProperty(requestContext.response, 'status', {
+        enumerable: false
+    });
+    if (void 0 === ssrContext) return requestContext;
+    const { request, response } = ssrContext;
+    return {
+        request: {
+            url: request.url,
+            userAgent: request.userAgent,
+            cookie: request.cookie,
+            pathname: request.pathname,
+            query: {
+                ...request.query
+            },
+            params: {
+                ...request.params
+            },
+            headers: {
+                ...request.headers
+            },
+            host: request.host,
+            referer: request.referer
+        },
+        response: Object.assign(requestContext.response, {
+            locals: response.locals ?? {}
+        })
+    };
+}
+function projectRuntimeContext(projection, options) {
+    let internalContext = projection.internalContext;
+    let publicContext = {
+        ...projection.publicContext
+    };
+    (0, external_contextExtensions_js_namespaceObject.stripRuntimeContextExtensions)(publicContext);
+    if (options.isRsc && false === options.context.isBrowser) {
+        const requestContext = createRscSafeRequestContext(options.context.ssrContext);
+        internalContext = {
+            ...internalContext,
+            context: requestContext,
+            requestContext
+        };
+        delete internalContext.ssrContext;
+        publicContext = {
+            ...publicContext,
+            context: requestContext,
+            requestContext
+        };
+    }
+    return {
+        internalContext,
+        publicContext
+    };
+}
+exports.projectRuntimeContext = __webpack_exports__.projectRuntimeContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "projectRuntimeContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server-config/bffRuntime.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server-config/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server-config/serverTelemetry.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shellStream.js

@@ -44,7 +44,7 @@ const createConservingWebShellStream = (source, context, marker, onMissingMarker
         markerFound = candidate.includes(marker);
         markerCarry = markerFound ? '' : candidate.slice(-(marker.length - 1));
     };
-    return source.pipeThrough(new TransformStream({
+    const transform = new TransformStream({
         transform (chunk, controller) {
             const decoded = decoder.decode(chunk, {
                 stream: true
@@ -65,7 +65,39 @@ const createConservingWebShellStream = (source, context, marker, onMissingMarker
             const output = headProcessor.finish(decoded);
             if (output) controller.enqueue(encoder.encode(output));
         }
-    }));
+    });
+    const piping = source.pipeTo(transform.writable);
+    piping.catch(()=>{});
+    const reader = transform.readable.getReader();
+    return new ReadableStream({
+        async pull (controller) {
+            try {
+                const result = await reader.read();
+                if (result.done) {
+                    await piping;
+                    controller.close();
+                    reader.releaseLock();
+                } else controller.enqueue(result.value);
+            } catch (error) {
+                await piping.catch(()=>{});
+                controller.error(error);
+                reader.releaseLock();
+            }
+        },
+        async cancel (reason) {
+            try {
+                await reader.cancel(reason);
+            } finally{
+                try {
+                    await piping.catch((error)=>{
+                        if (error !== reason) throw error;
+                    });
+                } finally{
+                    reader.releaseLock();
+                }
+            }
+        }
+    });
 };
 exports.createConservingWebShellStream = __webpack_exports__.createConservingWebShellStream;
 for(var __rspack_i in __webpack_exports__)if (-1 === [

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/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/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/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 };