@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/dist/esm-node/rsc-disabled/rscDisabledClientEdgeRuntime.mjs

@@ -0,0 +1,9 @@
+import "node:module";
+import { disabledRscRuntime } from "./rscDisabledRuntimeError.mjs";
+const createFromFetch = disabledRscRuntime;
+const createFromReadableStream = disabledRscRuntime;
+const createServerReference = disabledRscRuntime;
+const createTemporaryReferenceSet = disabledRscRuntime;
+const encodeReply = disabledRscRuntime;
+const registerServerReference = disabledRscRuntime;
+export { createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, registerServerReference };

package/dist/esm-node/rsc-disabled/rscDisabledClientNodeRuntime.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+import { disabledRscRuntime } from "./rscDisabledRuntimeError.mjs";
+const createFromFetch = disabledRscRuntime;
+const createFromNodeStream = disabledRscRuntime;
+const createFromReadableStream = disabledRscRuntime;
+const createServerReference = disabledRscRuntime;
+const createTemporaryReferenceSet = disabledRscRuntime;
+const encodeReply = disabledRscRuntime;
+const registerServerReference = disabledRscRuntime;
+export { createFromFetch, createFromNodeStream, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, registerServerReference };

package/dist/esm-node/rsc-disabled/rscDisabledRuntimeError.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+function disabledRscRuntime() {
+    throw new Error('React Server Components are disabled for this build.');
+}
+export { disabledRscRuntime };

package/dist/esm-node/rsc-disabled/rscDisabledServerEdgeRuntime.mjs

@@ -0,0 +1,17 @@
+import "node:module";
+import { disabledRscRuntime } from "./rscDisabledRuntimeError.mjs";
+const createServerEntry = disabledRscRuntime;
+const createTemporaryReferenceSet = disabledRscRuntime;
+const decodeAction = disabledRscRuntime;
+const decodeFormState = disabledRscRuntime;
+const decodeReply = disabledRscRuntime;
+const decodeReplyFromAsyncIterable = disabledRscRuntime;
+const decryptServerActionBoundArgs = disabledRscRuntime;
+const encryptServerActionBoundArgs = disabledRscRuntime;
+const ensureServerActions = disabledRscRuntime;
+const loadServerAction = disabledRscRuntime;
+const registerClientReference = disabledRscRuntime;
+const registerServerReference = disabledRscRuntime;
+const renderToReadableStream = disabledRscRuntime;
+const setServerActionBoundArgsEncryption = disabledRscRuntime;
+export { createServerEntry, createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, decodeReplyFromAsyncIterable, decryptServerActionBoundArgs, encryptServerActionBoundArgs, ensureServerActions, loadServerAction, registerClientReference, registerServerReference, renderToReadableStream, setServerActionBoundArgsEncryption };

package/dist/esm-node/rsc-disabled/rscDisabledServerNodeRuntime.mjs

@@ -0,0 +1,19 @@
+import "node:module";
+import { disabledRscRuntime } from "./rscDisabledRuntimeError.mjs";
+const createServerEntry = disabledRscRuntime;
+const createTemporaryReferenceSet = disabledRscRuntime;
+const decodeAction = disabledRscRuntime;
+const decodeFormState = disabledRscRuntime;
+const decodeReply = disabledRscRuntime;
+const decodeReplyFromAsyncIterable = disabledRscRuntime;
+const decodeReplyFromBusboy = disabledRscRuntime;
+const decryptServerActionBoundArgs = disabledRscRuntime;
+const encryptServerActionBoundArgs = disabledRscRuntime;
+const ensureServerActions = disabledRscRuntime;
+const loadServerAction = disabledRscRuntime;
+const registerClientReference = disabledRscRuntime;
+const registerServerReference = disabledRscRuntime;
+const renderToPipeableStream = disabledRscRuntime;
+const renderToReadableStream = disabledRscRuntime;
+const setServerActionBoundArgsEncryption = disabledRscRuntime;
+export { createServerEntry, createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, decodeReplyFromAsyncIterable, decodeReplyFromBusboy, decryptServerActionBoundArgs, encryptServerActionBoundArgs, ensureServerActions, loadServerAction, registerClientReference, registerServerReference, renderToPipeableStream, renderToReadableStream, setServerActionBoundArgsEncryption };

package/dist/esm-node/runtimeContextProjection.mjs

@@ -0,0 +1,75 @@
+import "node:module";
+import { stripRuntimeContextExtensions } from "./contextExtensions.mjs";
+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
+    };
+    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
+    };
+}
+export { projectRuntimeContext };

package/dist/esm-node/server-config/bffRuntime.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/server-config/index.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/server-config/serverTelemetry.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/shellStream.mjs

@@ -13,7 +13,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
@@ -34,6 +34,38 @@ 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();
+                }
+            }
+        }
+    });
 };
 export { createConservingWebShellStream };

package/dist/esm-node/workspaceEvents.mjs

@@ -0,0 +1,67 @@
+import "node:module";
+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);
+export { UltramodernWorkspaceEventValidationError, assertUltramodernWorkspaceEventPayload, createUltramodernWorkspaceEvent, dispatchUltramodernNavigate, dispatchUltramodernPerformanceSignal, dispatchUltramodernRemoteReady, dispatchUltramodernRouteSettled, dispatchUltramodernWorkspaceEvent, isUltramodernNavigatePayload, isUltramodernPerformanceSignalPayload, isUltramodernRemoteReadyPayload, isUltramodernRouteSettledPayload, isUltramodernWorkspaceEventPayload, onUltramodernNavigate, onUltramodernPerformanceSignal, onUltramodernRemoteReady, onUltramodernRouteSettled, onUltramodernWorkspaceEvent, ultramodernWorkspaceEventNames };

package/dist/types/buildIdentity.d.ts

@@ -0,0 +1,37 @@
+interface BuildIdentity {
+    readonly build: string;
+    readonly buildMarker: string;
+    readonly sourceRevision: string;
+}
+interface BuildArtifact {
+    readonly deliveryUnit: BuildIdentity;
+    readonly surfaces: {
+        readonly api: BuildIdentity;
+        readonly ui: BuildIdentity;
+    };
+}
+interface BuildIdentityReaders {
+    readonly buildMarker: () => string;
+    readonly sourceRevision: () => string;
+}
+/** Read compiler constants in the caller, even when this package is external. */
+export declare function resolveUltramodernBuildArtifact<Artifact extends BuildArtifact>(artifact: Artifact, readers?: BuildIdentityReaders): Artifact & {
+    deliveryUnit: {
+        build: string;
+        buildMarker: string;
+        sourceRevision: string;
+    };
+    surfaces: {
+        api: {
+            build: string;
+            buildMarker: string;
+            sourceRevision: string;
+        };
+        ui: {
+            build: string;
+            buildMarker: string;
+            sourceRevision: string;
+        };
+    };
+};
+export {};

package/dist/types/contextExtensions.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Fork-owned runtime-context extension mechanism.
+ *
+ * Plugins must not add ad-hoc fields to `TRuntimeContext` /
+ * `TInternalRuntimeContext`. Instead they store state in a single internal
+ * slot (a `Map` keyed by symbol) attached to the context object under a
+ * symbol property, so nothing leaks into string-key enumeration
+ * (`Object.keys`, `JSON.stringify`). Object spreads preserve the slot.
+ *
+ * `Symbol.for` is used for both the slot and the extension keys so that the
+ * mechanism stays coherent even if this module is instantiated twice
+ * (e.g. esm/cjs interop in test runners).
+ */
+export interface RuntimeContextExtension<T> {
+    /** Stable identity of this extension. */
+    readonly key: symbol;
+    get(context: object): T | undefined;
+    set(context: object, value: T): void;
+    remove(context: object): void;
+}
+/**
+ * Removes the extension slot from a context object.
+ *
+ * The symbol slot crosses object spreads while remaining absent from string-key
+ * enumeration and JSON. Callers can still explicitly clear the original context.
+ */
+export declare function stripRuntimeContextExtensions(context: object): void;
+/**
+ * Creates a typed accessor pair over the shared extension slot.
+ *
+ * The `id` must be globally unique (it is interned via `Symbol.for`); use a
+ * package-prefixed name such as `@modern-js/plugin-tanstack:router-state`.
+ */
+export declare function createRuntimeContextExtension<T>(id: string): RuntimeContextExtension<T>;

package/dist/types/headRuntime.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Helmet as AsyncHelmet, type HelmetProps } from 'react-helmet-async';
+import type { HelmetContextSlot } from './helmetContext.js';
+export interface HeadRenderContext {
+    runtimeContext: object;
+    helmetContext: HelmetContextSlot;
+}
+export declare function createHeadRuntime(): {
+    Head: (props: React.PropsWithChildren<HelmetProps>) => React.CElement<React.PropsWithChildren<HelmetProps>, AsyncHelmet> | React.ReactElement<{}, string | React.JSXElementConstructor<any>> | null;
+    wrapServerRoot(root: React.ReactNode, state: HeadRenderContext): React.JSX.Element;
+    wrapClientRoot(root: React.ReactNode): React.JSX.Element;
+};

package/dist/types/helmetContext.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fork-owned helmet state, stored via the runtime-context extension slot
+ * instead of an ad-hoc `_helmetContext` field on `TInternalRuntimeContext`.
+ */
+import type { HelmetServerState } from 'react-helmet-async';
+export interface HelmetContextSlot {
+    helmet?: HelmetServerState | null;
+}
+export declare function getHelmetContext(context: object): HelmetContextSlot | undefined;
+export declare function ensureHelmetContext(context: object): HelmetContextSlot;

package/dist/types/index.d.ts

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

package/dist/types/localisedLoaderIdentity.d.ts

@@ -0,0 +1,10 @@
+interface RouteNode {
+    id?: string;
+    children?: RouteNode[];
+    modernLocalisedRoute?: {
+        id?: string;
+    };
+}
+/** Map a source loader ID only to its own alias already matched by the router. */
+export declare function resolveLocalisedLoaderRouteId(routes: RouteNode[], requestedId: string, matchedIds?: (string | undefined)[]): string;
+export {};

package/dist/types/prefetchPolicy.d.ts

@@ -0,0 +1,4 @@
+type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+export declare function resolvePreloadFromPrefetch(prefetch: PrefetchBehavior | undefined, preload: unknown): {} | null;
+export declare function normalizePreloadBehavior(preload: PrefetchBehavior | false | undefined, prefetch: PrefetchBehavior): PrefetchBehavior;
+export {};

package/dist/types/reactContext.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Federation can bundle a runtime subpath separately from its shared root.
+ * Share React context identity across those copies, leaving request values to
+ * React's providers. Public and internal contexts retain separate identities.
+ */
+export declare function getRuntimeReactContext<T>(kind: 'public' | 'internal', create: () => T): T;

package/dist/types/request-policy/browser.d.ts

@@ -0,0 +1,10 @@
+/** Create a browser producer client with its own configuration and policy. */
+export declare const createClient: () => {
+    configure: (options: import("./types.js").IOptions<typeof fetch>) => void;
+    createRequest: import("./types.js").RequestCreator<typeof fetch>;
+    createUploader: import("./types.js").UploadCreator;
+};
+export declare const configure: (options: import("./types.js").IOptions<typeof fetch>) => void, createRequest: import("./types.js").RequestCreator<typeof fetch>, createUploader: import("./types.js").UploadCreator;
+export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, } from './policyCore.js';
+export * from './requestContext.js';
+export * from './types.js';

package/dist/types/request-policy/client.d.ts

@@ -0,0 +1,14 @@
+import type { RequestClient } from '@modern-js/create-request/client';
+import type { IOptions, RequestCreator, TransportTarget, UploadCreator } from './types.js';
+type HeaderMap = Record<string, any>;
+type PolicyEnvironment = {
+    target: TransportTarget;
+    resolveSourceOrigin: (incomingHeaders: HeaderMap) => string | undefined;
+};
+/** Bind fork producer policy to one isolated native request client. */
+export declare const createPolicyClient: <F>(nativeClient: RequestClient<F>, environment: PolicyEnvironment) => {
+    configure: (options: IOptions<F>) => void;
+    createRequest: RequestCreator<F>;
+    createUploader: UploadCreator;
+};
+export {};

package/dist/types/request-policy/node.d.ts

@@ -0,0 +1,10 @@
+/** Create a server producer client with its own configuration and policy. */
+export declare const createClient: () => {
+    configure: (options: import("./types.js").IOptions<typeof fetch>) => void;
+    createRequest: import("./types.js").RequestCreator<typeof fetch>;
+    createUploader: import("./types.js").UploadCreator;
+};
+export declare const configure: (options: import("./types.js").IOptions<typeof fetch>) => void, createRequest: import("./types.js").RequestCreator<typeof fetch>, createUploader: import("./types.js").UploadCreator;
+export { CrossOriginEnvelopePolicyError, IdentityBindingViolationError, OperationContractViolationError, ProducerClientNotInitializedError, ProducerDomainNotConfiguredError, } from './policyCore.js';
+export * from './requestContext.js';
+export * from './types.js';

package/dist/types/request-policy/policyCore.d.ts

@@ -0,0 +1,107 @@
+import type { IdentityBindingViolation, OperationContext, OperationContractOptions, OperationContractViolation, TransportTarget } from './types.js';
+export declare const TRACEPARENT_HEADER = "traceparent";
+export declare const isSecuredRequestId: (requestId: string) => boolean;
+export declare const isEmptyDomain: (domain?: string) => boolean;
+export declare const firstHeaderValue: (value: unknown) => any;
+export declare const findHeaderKey: (headers: Record<string, any>, header: string) => string | undefined;
+export declare const readHeader: (headers: Record<string, any>, header: string) => any;
+export declare const writeHeader: (headers: Record<string, any>, header: string, value: unknown) => void;
+export declare const deleteHeader: (headers: Record<string, any>, header: string) => void;
+export declare const toOrigin: (value?: string) => string | undefined;
+export declare const parseTraceparentValue: (value: unknown) => import("./traceparent.js").TraceparentContext | undefined;
+export declare const buildOperationContext: ({ requestId, method, path, operationContext, traceparent, }: {
+    requestId: string;
+    method: string;
+    path: string;
+    operationContext?: OperationContext | undefined;
+    traceparent?: unknown;
+}) => {
+    requestId: string;
+    operationId: string;
+    routePath: string;
+    method: string;
+    schemaHash?: string | undefined;
+    operationVersion?: number | undefined;
+    traceparent?: string | undefined;
+    traceId?: string | undefined;
+    spanId?: string | undefined;
+};
+type OperationContextPayload = ReturnType<typeof buildOperationContext>;
+export declare class ProducerClientNotInitializedError extends Error {
+    readonly code = "BFF_PRODUCER_CLIENT_NOT_INITIALIZED";
+    constructor(requestId: string);
+}
+export declare class ProducerDomainNotConfiguredError extends Error {
+    readonly code = "BFF_PRODUCER_DOMAIN_NOT_CONFIGURED";
+    constructor(requestId: string);
+}
+export declare class CrossOriginEnvelopePolicyError extends Error {
+    readonly code = "BFF_CROSS_ORIGIN_ENVELOPE_NOT_ALLOWED";
+    constructor(requestId: string, sourceOrigin?: string, targetOrigin?: string);
+}
+export declare class IdentityBindingViolationError extends Error {
+    readonly code = "BFF_IDENTITY_BINDING_VIOLATION";
+    readonly violation: IdentityBindingViolation;
+    constructor(violation: IdentityBindingViolation);
+}
+export declare class OperationContractViolationError extends Error {
+    readonly code = "BFF_OPERATION_CONTRACT_VIOLATION";
+    readonly violation: OperationContractViolation;
+    constructor(violation: OperationContractViolation);
+}
+export declare const validateOperationContract: ({ requestId, target, contextPayload, operationContract, }: {
+    requestId: string;
+    target: TransportTarget;
+    contextPayload: OperationContextPayload;
+    operationContract: OperationContractOptions | undefined;
+}) => void;
+export declare const resolveConfiguredRequest: <F>(configuredRequests: Map<string, F>, requestId: string, fallback: F) => F;
+/**
+ * Builds the JSON value for the `x-modernjs-bff-envelope` header and throws
+ * when the cross-origin envelope policy denies the flow. Returns the
+ * serialized envelope.
+ */
+export declare const buildEnvelopeHeaderValue: ({ requestId, target, sourceOrigin, targetOrigin, traceContext, allowCrossOriginEnvelope, }: {
+    requestId: string;
+    target: TransportTarget;
+    sourceOrigin: string | undefined;
+    targetOrigin: string | undefined;
+    traceContext: {
+        traceId: string;
+        spanId: string;
+    } | null | undefined;
+    allowCrossOriginEnvelope: boolean | ((options: {
+        requestId: string;
+        sourceOrigin?: string;
+        targetOrigin?: string;
+        target: TransportTarget;
+    }) => boolean) | undefined;
+}) => string;
+/**
+ * Derives the operation context for a secured requestId, validates it against
+ * the configured operation contract and writes the `x-operation-id` and
+ * `x-modernjs-bff-operation-context` headers (without clobbering caller
+ * provided values for the id header).
+ */
+export declare const attachOperationContextHeaders: ({ headers, requestId, target, method, path, operationContext, operationContract, operationContextHeader, operationContextDetailHeader, }: {
+    headers: Record<string, any>;
+    requestId: string;
+    target: TransportTarget;
+    method: string;
+    path: string;
+    operationContext: OperationContext | undefined;
+    operationContract: OperationContractOptions | undefined;
+    operationContextHeader: string;
+    operationContextDetailHeader: string;
+}) => {
+    requestId: string;
+    operationId: string;
+    routePath: string;
+    method: string;
+    schemaHash?: string | undefined;
+    operationVersion?: number | undefined;
+    traceparent?: string | undefined;
+    traceId?: string | undefined;
+    spanId?: string | undefined;
+};
+export {};

package/dist/types/request-policy/requestContext.d.ts

@@ -0,0 +1,22 @@
+import type { OperationContext } from './types.js';
+export declare const BFF_LOCALE_HEADER = "accept-language";
+export declare const BFF_TRACEPARENT_HEADER = "traceparent";
+export type RequestContextInput = {
+    headers?: Record<string, unknown>;
+    locale?: string;
+    traceparent?: string;
+    operationContext?: OperationContext;
+};
+export type RequestContextSnapshot = {
+    headers: Record<string, string>;
+    locale?: string;
+    traceparent?: string;
+    traceId?: string;
+    spanId?: string;
+    operationContext?: OperationContext;
+};
+export declare function createRequestContextSnapshot(input?: RequestContextInput): RequestContextSnapshot;
+export declare function createRequestContextHeaders(input?: RequestContextInput): Record<string, string>;
+export { parseTraceparent, type TraceparentContext } from './traceparent.js';
+export type * from './types.js';
+export { BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS, BFF_ENVELOPE_HEADER, BFF_OPERATION_CONTEXT_DETAIL_HEADER, BFF_OPERATION_CONTEXT_HEADER, } from './types.js';

package/dist/types/request-policy/traceparent.d.ts

@@ -0,0 +1,10 @@
+export type TraceparentContext = {
+    traceId: string;
+    spanId: string;
+    sampled: boolean;
+};
+/**
+ * Parse a W3C trace context `traceparent` header (version 00).
+ * All-zero trace ids and span ids are rejected per the W3C spec.
+ */
+export declare function parseTraceparent(traceparent: string | undefined | null): TraceparentContext | undefined;

package/dist/types/request-policy/transport.d.ts

@@ -0,0 +1,12 @@
+import type { TransportResilienceOptions, TransportTarget } from './types.js';
+type ExecuteWithResilienceOptions = {
+    requestId: string;
+    target: TransportTarget;
+    method: string;
+    url: string;
+    init: Record<string, any>;
+    fetcher: (...args: any[]) => Promise<any>;
+    transport?: TransportResilienceOptions;
+};
+export declare const executeWithResilience: ({ requestId, target, method, url, init, fetcher, transport, }: ExecuteWithResilienceOptions) => Promise<any>;
+export {};