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

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

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

@@ -0,0 +1,144 @@
+import type { HttpMethodDecider, IOptions as NativeOptions, RequestCreatorOptions as NativeRequestCreatorOptions, UploadCreatorOptions as NativeUploadCreatorOptions, Sender } from '@modern-js/create-request/client';
+export type { BFFRequestPayload, HttpMethodDecider, Sender, } from '@modern-js/create-request/client';
+export declare const BFF_ENVELOPE_HEADER = "x-modernjs-bff-envelope";
+export declare const BFF_OPERATION_CONTEXT_HEADER = "x-operation-id";
+export declare const BFF_OPERATION_CONTEXT_DETAIL_HEADER = "x-modernjs-bff-operation-context";
+export declare const BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS: readonly ['x-tenant-id', 'x-subject-id', 'x-user-id', "x-operation-id"];
+export type ResolveHeadersOptions = {
+    requestId: string;
+    allowedHeaders: string[];
+    incomingHeaders: Record<string, any>;
+};
+export type ResolveHeaders = (options: ResolveHeadersOptions) => Record<string, any> | void;
+export type AllowCrossOriginEnvelopeOptions = {
+    requestId: string;
+    sourceOrigin?: string;
+    targetOrigin?: string;
+    target: 'server' | 'browser';
+};
+export type AllowCrossOriginEnvelope = boolean | ((options: AllowCrossOriginEnvelopeOptions) => boolean);
+export type TransportTarget = 'server' | 'browser';
+export type RetryDecisionContext = {
+    requestId: string;
+    target: TransportTarget;
+    method: string;
+    url: string;
+    attempt: number;
+    maxAttempts: number;
+    error: unknown;
+    statusCode?: number;
+};
+export type RetryBackoffOptions = {
+    retries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitterRatio?: number;
+    retryableStatusCodes?: number[];
+    shouldRetry?: (context: RetryDecisionContext) => boolean;
+};
+export type DegradedModeReason = 'timeout' | 'retry' | 'retry_exhausted';
+export type DegradedModeEvent = {
+    requestId: string;
+    target: TransportTarget;
+    method: string;
+    url: string;
+    reason: DegradedModeReason;
+    attempt: number;
+    maxAttempts: number;
+    timeoutMs?: number;
+    backoffMs?: number;
+    statusCode?: number;
+    error?: unknown;
+};
+export type TransportResilienceOptions = {
+    timeoutMs?: number;
+    retry?: RetryBackoffOptions;
+    onDegraded?: (event: DegradedModeEvent) => void;
+};
+export type IdentityBindingViolationReason = 'client_override_blocked' | 'client_override_rejected';
+export type IdentityBindingViolation = {
+    requestId: string;
+    target: TransportTarget;
+    header: string;
+    reason: IdentityBindingViolationReason;
+    attemptedValue?: unknown;
+    derivedValue?: unknown;
+};
+export type DeriveIdentityHeadersOptions = {
+    requestId: string;
+    target: TransportTarget;
+    incomingHeaders: Record<string, any>;
+    protectedHeaders: string[];
+};
+export type IdentityBindingOptions = {
+    enabled?: boolean;
+    strict?: boolean;
+    protectedHeaders?: string[];
+    deriveHeaders?: (options: DeriveIdentityHeadersOptions) => Record<string, any> | void;
+    onViolation?: (violation: IdentityBindingViolation) => void;
+};
+export type OperationContractViolationReason = 'missing_schema_hash' | 'missing_operation_version';
+export type OperationContractViolation = {
+    requestId: string;
+    target: TransportTarget;
+    operationId: string;
+    reason: OperationContractViolationReason;
+    routePath?: string;
+    method?: string;
+    schemaHash?: string;
+    operationVersion?: number;
+};
+export type CrossProjectOperationContract = {
+    schemaHash?: string;
+    operationVersion?: number;
+};
+export type CrossProjectPolicyViolationReason = 'missing_envelope' | 'invalid_envelope' | 'missing_request_id' | 'namespace_not_allowed' | 'missing_operation_context' | 'operation_context_mismatch' | 'missing_operation_context_details' | 'invalid_operation_context_details' | 'operation_context_details_request_id_mismatch' | 'missing_operation_schema_hash' | 'missing_operation_version' | 'unknown_operation_contract' | 'operation_schema_hash_mismatch' | 'operation_version_mismatch' | 'producer_identity_mismatch';
+export type CrossProjectPolicyViolation = {
+    code: 'BFF_CROSS_PROJECT_POLICY_DENIED';
+    reason: CrossProjectPolicyViolationReason;
+    message: string;
+    status: number;
+};
+export type OperationContractOptions = {
+    enabled?: boolean;
+    strict?: boolean;
+    requireSchemaHash?: boolean;
+    requireOperationVersion?: boolean;
+    onViolation?: (violation: OperationContractViolation) => void;
+};
+export type OperationContextSource = 'client' | 'server' | 'generated-client' | 'effect-adapter' | 'data-platform' | 'unknown';
+export type OperationContext = {
+    requestId?: string;
+    operationId?: string;
+    routePath?: string;
+    method?: string;
+    schemaHash?: string;
+    operationVersion?: number;
+    locale?: string;
+    traceparent?: string;
+    traceId?: string;
+    spanId?: string;
+    source?: OperationContextSource;
+    scope?: Record<string, unknown>;
+    sessionClaims?: Record<string, unknown>;
+    attributes?: Record<string, unknown>;
+};
+export type RequestCreatorOptions<F = typeof fetch> = Omit<NativeRequestCreatorOptions<F>, 'hooks'> & {
+    operationContext?: OperationContext;
+};
+export type RequestCreator<F = typeof fetch> = {
+    (options: RequestCreatorOptions<F>): Sender;
+    (path: string, method: string, port: number, httpMethodDecider?: HttpMethodDecider, fetch?: F, requestId?: string, operationContext?: OperationContext): Sender;
+};
+export type UploadCreatorOptions = Omit<NativeUploadCreatorOptions, 'hooks'> & {
+    operationContext?: OperationContext;
+};
+export type UploadCreator = (options: UploadCreatorOptions) => Sender;
+export type IOptions<F = typeof fetch> = NativeOptions<F> & {
+    resolveHeaders?: ResolveHeaders;
+    transport?: TransportResilienceOptions;
+    requireEnvelope?: boolean;
+    allowCrossOriginEnvelope?: AllowCrossOriginEnvelope;
+    identityBinding?: IdentityBindingOptions;
+    operationContract?: OperationContractOptions;
+};

package/dist/types/routeHydration.d.ts

@@ -0,0 +1,24 @@
+type RouteAssetManifest = {
+    assets?: string[];
+};
+export type RouteManifestLike = {
+    routeAssets?: Record<string, RouteAssetManifest | undefined>;
+};
+export type ScriptChunkLike = {
+    filename?: string;
+    url?: string;
+};
+export declare function getMatchedRouteChunks<T>(routeManifest: RouteManifestLike | undefined, matchedRouteIds: string[], routeAssetToChunk: (asset: string) => T): T[];
+export declare const orderHydrationScriptChunks: <T extends ScriptChunkLike>({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName, }: {
+    asyncEntryChunks: T[];
+    collectedChunks: T[];
+    matchedRouteChunks: T[];
+    entryName: string;
+}) => T[];
+export declare function injectBeforeHydrationEntryScript(template: string, scripts: string, entryName?: string): string;
+export declare function replaceChunkJsPlaceholder(template: string, scripts: string, entryName: string | undefined, placeholder: string): string;
+export declare function createRouteHydrationScriptTags(routeManifest: RouteManifestLike | undefined, matchedRouteIds: string[], entryName: string, options?: {
+    nonce?: string;
+    template?: string;
+}): string;
+export {};