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

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

package/dist/types/routerPrefetchPolicy.d.ts

@@ -0,0 +1,28 @@
+type PrefetchBehavior = 'intent' | 'render' | 'viewport' | 'none';
+type PrefetchState = {
+    code: boolean;
+    data: boolean;
+};
+/** Policy-only contract: native links supply elements, route inputs and loads. */
+export declare function createRouterPrefetchPolicy(): {
+    canWarmup: () => boolean;
+    allowData(route: unknown): boolean;
+    observe({ element, prefetch: inputPrefetch, preload: inputPreload, notify, }: {
+        element: HTMLAnchorElement | null;
+        prefetch?: PrefetchBehavior;
+        preload?: PrefetchBehavior | false;
+        notify: (state: PrefetchState) => void;
+    }): {
+        onIntent(): void;
+        onCancel(): void;
+        dispose(): void;
+    };
+    schedule({ runtimeContext, chunkLoader, publicPath, key: operationKey, run, }: {
+        runtimeContext: object;
+        chunkLoader: object;
+        publicPath: string;
+        key: string;
+        run: () => Promise<unknown>;
+    }): () => void;
+};
+export {};

package/dist/types/routerProvider.d.ts

@@ -0,0 +1,55 @@
+/** Structural plugin contract; the composing integration supplies native hooks. */
+export type RouterProviderPlugin = {
+    name?: string;
+    registryHooks?: Record<string, unknown>;
+    setup?: (api: any) => unknown;
+    [key: string]: unknown;
+};
+/**
+ * Guard for the wrapper plugin (`router/internal`): a resolved provider is
+ * only invoked through `setup`, so registry hooks outside the canonical
+ * router hook contract cannot be registered for it. Returns the offending
+ * hook names and warns once so they are surfaced instead of silently dropped.
+ */
+export declare function reportUnsupportedProviderRegistryHooks(providerPlugin: {
+    name?: string;
+    registryHooks?: Record<string, unknown>;
+}, routerProviderRegistryHooks: Record<string, unknown>): string[];
+export type RouterProviderFactory = (userConfig?: any) => RouterProviderPlugin;
+export type RouterProviderRegistration = {
+    name: string;
+    factory: RouterProviderFactory;
+    isDefault?: boolean;
+};
+/**
+ * App-owned provider catalog. Provider factories close over their module graph,
+ * so they must be resolved from the runtime wrapper that owns the app instead
+ * of from a page-global first-registration winner.
+ */
+export type RouterProviderRealm = Readonly<{
+    defaultProvider?: string;
+    get: (name: string) => RouterProviderFactory | undefined;
+    names: () => readonly string[];
+}>;
+export declare function createRouterProviderRealm(registrations: readonly RouterProviderRegistration[]): RouterProviderRealm;
+export declare function resolveRouterProvider(framework: string | undefined, options: {
+    realm: RouterProviderRealm;
+}): RouterProviderFactory;
+/** Compose app-owned providers without importing the native runtime graph. */
+export declare function createRouterPlugin<Hooks extends Record<string, unknown>>({ defaultProvider, registryHooks, localProviders, }: {
+    defaultProvider: {
+        name: string;
+        factory: RouterProviderFactory;
+    };
+    registryHooks: Hooks;
+    localProviders?: readonly Omit<RouterProviderRegistration, 'isDefault'>[];
+}): (userConfig?: Record<string, any>) => {
+    name: string;
+    registryHooks: Hooks;
+    setup(api: {
+        getRuntimeConfig: () => {
+            router?: Record<string, unknown>;
+        };
+        [key: string]: any;
+    }): void;
+};

package/dist/types/routerState.d.ts

@@ -0,0 +1,18 @@
+import type { InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterServerPrepareResult } from './routerStateTypes.js';
+export type { BuiltInRouterFramework, InternalRouterRuntimeState, InternalRouterServerSnapshot, RouterFramework, RouterLifecyclePhase, RouterRouteMatchSnapshot, RouterServerPrepareResult, } from './routerStateTypes.js';
+export declare function getRouterRuntimeState(runtimeContext: object): InternalRouterRuntimeState | undefined;
+export declare function getRouterServerSnapshot(runtimeContext: object): InternalRouterServerSnapshot | undefined;
+type RouterSnapshotLike = Partial<InternalRouterServerSnapshot>;
+export declare function createRouterServerSnapshot(state: RouterSnapshotLike): InternalRouterServerSnapshot;
+export declare function createRouterRuntimeState(state: InternalRouterRuntimeState): InternalRouterRuntimeState;
+/**
+ * Observe the router runtime-state slot for the given runtime context.
+ * Returns an unsubscribe function; safe to call for a context that never
+ * receives a router.
+ */
+export declare function subscribeRouterRuntimeState(runtimeContext: object, listener: () => void): () => void;
+export declare function applyRouterRuntimeState<Context extends object>(runtimeContext: Context, state: InternalRouterRuntimeState): Context;
+export declare function applyRouterServerPrepareResult<Context extends object>(runtimeContext: Context, result: RouterServerPrepareResult): Context;
+export declare function getRouterHydrationScripts(runtimeContext: object): string[];
+export declare function getRouterMatchedRouteIds(runtimeContext: object): string[] | undefined;
+export declare function cleanupRouterRuntimeState(runtimeContext: object): Promise<void>;

package/dist/types/routerStatePlugin.d.ts

@@ -0,0 +1,19 @@
+type RouterLifecycleEvent = {
+    framework: string;
+    phase: string;
+    runtimeContext: object;
+    basename?: string;
+    router?: unknown;
+};
+/** Install fork policy through lifecycle hooks supplied by the native owner. */
+export declare function createRouterStatePlugin<Hooks extends Record<string, unknown>>({ registryHooks, }: {
+    registryHooks: Hooks;
+}): {
+    name: string;
+    registryHooks: Hooks;
+    setup(api: {
+        onBeforeRender: (callback: (context: object) => void) => unknown;
+        onAfterCreateRouter: (callback: (event: RouterLifecycleEvent) => void) => unknown;
+    }): void;
+};
+export {};

package/dist/types/routerStateTypes.d.ts

@@ -0,0 +1,40 @@
+export type BuiltInRouterFramework = 'react-router' | 'tanstack';
+export type RouterFramework = BuiltInRouterFramework | (string & {});
+export interface RouterRouteMatchSnapshot {
+    routeId: string;
+    assetRouteId?: string;
+    pathname?: string;
+    params?: Record<string, string>;
+}
+export interface InternalRouterServerSnapshot {
+    framework?: RouterFramework;
+    basename?: string;
+    statusCode?: number;
+    errors?: Record<string, unknown>;
+    routerData?: {
+        loaderData?: Record<string, unknown>;
+        errors?: Record<string, unknown>;
+    };
+    hydrationScript?: string;
+    hydrationScripts?: string[];
+    matchedRouteIds?: string[];
+    matches?: RouterRouteMatchSnapshot[];
+}
+export interface InternalRouterRuntimeState {
+    framework: RouterFramework;
+    basename?: string;
+    instance?: unknown;
+    hydrationScript?: string;
+    hydrationScripts?: string[];
+    matchedRouteIds?: string[];
+    matches?: RouterRouteMatchSnapshot[];
+    serverSnapshot?: InternalRouterServerSnapshot;
+    cleanup?: () => void | Promise<void>;
+}
+export interface RouterServerPrepareResult {
+    state: InternalRouterRuntimeState;
+    snapshot?: InternalRouterServerSnapshot;
+    redirect?: Response;
+    cleanup?: () => void | Promise<void>;
+}
+export type RouterLifecyclePhase = 'ssr-prepare' | 'client-create' | 'hydrate';

package/dist/types/rsc-disabled/rscDisabledClientBrowserRuntime.d.ts

@@ -0,0 +1,9 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createFromFetch: typeof disabledRscRuntime;
+export declare const createFromReadableStream: typeof disabledRscRuntime;
+export declare const createServerReference: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const encodeReply: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;
+export declare const setFindSourceMapURLCallback: typeof disabledRscRuntime;
+export declare const setServerCallback: typeof disabledRscRuntime;

package/dist/types/rsc-disabled/rscDisabledClientEdgeRuntime.d.ts

@@ -0,0 +1,7 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createFromFetch: typeof disabledRscRuntime;
+export declare const createFromReadableStream: typeof disabledRscRuntime;
+export declare const createServerReference: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const encodeReply: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;

package/dist/types/rsc-disabled/rscDisabledClientNodeRuntime.d.ts

@@ -0,0 +1,8 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createFromFetch: typeof disabledRscRuntime;
+export declare const createFromNodeStream: typeof disabledRscRuntime;
+export declare const createFromReadableStream: typeof disabledRscRuntime;
+export declare const createServerReference: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const encodeReply: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;

package/dist/types/rsc-disabled/rscDisabledRuntimeError.d.ts

@@ -0,0 +1 @@
+export declare function disabledRscRuntime(): never;

package/dist/types/rsc-disabled/rscDisabledServerEdgeRuntime.d.ts

@@ -0,0 +1,15 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createServerEntry: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const decodeAction: typeof disabledRscRuntime;
+export declare const decodeFormState: typeof disabledRscRuntime;
+export declare const decodeReply: typeof disabledRscRuntime;
+export declare const decodeReplyFromAsyncIterable: typeof disabledRscRuntime;
+export declare const decryptServerActionBoundArgs: typeof disabledRscRuntime;
+export declare const encryptServerActionBoundArgs: typeof disabledRscRuntime;
+export declare const ensureServerActions: typeof disabledRscRuntime;
+export declare const loadServerAction: typeof disabledRscRuntime;
+export declare const registerClientReference: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;
+export declare const renderToReadableStream: typeof disabledRscRuntime;
+export declare const setServerActionBoundArgsEncryption: typeof disabledRscRuntime;

package/dist/types/rsc-disabled/rscDisabledServerNodeRuntime.d.ts

@@ -0,0 +1,17 @@
+import { disabledRscRuntime } from './rscDisabledRuntimeError.js';
+export declare const createServerEntry: typeof disabledRscRuntime;
+export declare const createTemporaryReferenceSet: typeof disabledRscRuntime;
+export declare const decodeAction: typeof disabledRscRuntime;
+export declare const decodeFormState: typeof disabledRscRuntime;
+export declare const decodeReply: typeof disabledRscRuntime;
+export declare const decodeReplyFromAsyncIterable: typeof disabledRscRuntime;
+export declare const decodeReplyFromBusboy: typeof disabledRscRuntime;
+export declare const decryptServerActionBoundArgs: typeof disabledRscRuntime;
+export declare const encryptServerActionBoundArgs: typeof disabledRscRuntime;
+export declare const ensureServerActions: typeof disabledRscRuntime;
+export declare const loadServerAction: typeof disabledRscRuntime;
+export declare const registerClientReference: typeof disabledRscRuntime;
+export declare const registerServerReference: typeof disabledRscRuntime;
+export declare const renderToPipeableStream: typeof disabledRscRuntime;
+export declare const renderToReadableStream: typeof disabledRscRuntime;
+export declare const setServerActionBoundArgsEncryption: typeof disabledRscRuntime;

package/dist/types/runtimeContextProjection.d.ts

@@ -0,0 +1,30 @@
+interface ProjectionContext {
+    isBrowser?: boolean;
+    ssrContext?: {
+        request: {
+            url?: unknown;
+            userAgent?: unknown;
+            cookie?: unknown;
+            pathname?: unknown;
+            query?: object;
+            params?: object;
+            headers?: object;
+            host?: unknown;
+            referer?: unknown;
+        };
+        response: {
+            locals?: unknown;
+        };
+    };
+}
+export declare function projectRuntimeContext<InternalContext extends ProjectionContext, PublicContext extends ProjectionContext>(projection: {
+    internalContext: InternalContext;
+    publicContext: PublicContext;
+}, options: {
+    context: InternalContext;
+    isRsc: boolean;
+}): {
+    internalContext: InternalContext;
+    publicContext: PublicContext;
+};
+export {};

package/dist/types/server-config/bffRuntime.d.ts

@@ -0,0 +1,122 @@
+export type BffRuntimeFramework = 'hono' | 'effect';
+/** Fork BFF options, independent of any native server config interface. */
+export interface BffRuntimeUserConfig {
+    runtimeFramework?: BffRuntimeFramework;
+    effect?: BffEffectUserConfig;
+    crossProjectPolicy?: BffCrossProjectPolicyUserConfig;
+}
+export interface BffCrossProjectPolicyUserConfig {
+    /**
+     * Enable cross-project envelope and operation-context policy checks.
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Require cross-project envelope header when policy is enabled.
+     *
+     * @default true
+     */
+    requireEnvelope?: boolean;
+    /**
+     * Require operation-context header when policy is enabled.
+     *
+     * @default true
+     */
+    requireOperationContext?: boolean;
+    /**
+     * Require operation-context detail header carrying schema/version metadata.
+     *
+     * @default true
+     */
+    requireOperationContextDetails?: boolean;
+    /**
+     * Require operation schema hash in operation-context details.
+     *
+     * @default true
+     */
+    requireOperationSchemaHash?: boolean;
+    /**
+     * Require operation version in operation-context details.
+     *
+     * @default true
+     */
+    requireOperationVersion?: boolean;
+    /**
+     * Optional allowlist of producer namespaces derived from requestId.
+     */
+    allowedNamespaces?: string[];
+    /**
+     * Optional hook deriving a verified producer identity (namespace) from
+     * request headers, e.g. an mTLS subject or gateway-verified JWT claim.
+     * When provided, namespace checks bind to this verified value instead of
+     * the client-asserted requestId namespace; returning `undefined` denies
+     * the request. Without it the namespace checks are advisory only.
+     */
+    verifyProducerIdentity?: (headers: Record<string, unknown>) => string | undefined;
+    /**
+     * Optional operation-contract map keyed by:
+     * - `${METHOD}:${routePath}`
+     * - `operation:${requestId}:${operationId}`
+     */
+    expectedOperationContracts?: Record<string, {
+        schemaHash?: string;
+        operationVersion?: number;
+    }>;
+    /**
+     * Allow operations missing from expectedOperationContracts.
+     *
+     * @default false
+     */
+    allowUnknownOperations?: boolean;
+    /**
+     * HTTP status code used for denied requests.
+     *
+     * @default 403
+     */
+    denyStatus?: number;
+}
+export type BffEffectOpenApiUserConfig = boolean | {
+    path?: string;
+};
+export interface BffEffectDataPlatformSelectionUserConfig {
+    maxDepth?: number;
+    maxFields?: number;
+    allowedLeafPaths?: string[];
+}
+export interface BffEffectDataPlatformBatchUserConfig {
+    enabled?: boolean;
+    endpoint?: `/${string}`;
+    maxBatchSize?: number;
+    maxBatchBytes?: number;
+    flushIntervalMs?: number;
+    maxConcurrency?: number;
+    requestTimeoutMs?: number;
+    allowedMethods?: string[];
+}
+export interface BffEffectDataPlatformUserConfig {
+    enabled?: boolean;
+    requireEnvelope?: boolean;
+    envelopeHeader?: string;
+    expectedNamespace?: string;
+    validateOrigin?: boolean;
+    requireTraceContext?: boolean;
+    selection?: BffEffectDataPlatformSelectionUserConfig;
+    batch?: BffEffectDataPlatformBatchUserConfig;
+}
+export interface BffEffectUserConfig {
+    entry?: string;
+    /**
+     * Enforce Effect-native API/runtime modules instead of raw request handlers.
+     *
+     * Effect API entries must export a `defineEffectBff(...)`
+     * definition or a `{ api, layer }` HttpApi module. Raw `handler` exports,
+     * default request handlers, and unbranded custom `createHandler` factories
+     * are rejected.
+     *
+     * @default true
+     */
+    strictEffectApproach?: true;
+    openapi?: BffEffectOpenApiUserConfig;
+    dataPlatform?: BffEffectDataPlatformUserConfig;
+}

package/dist/types/server-config/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './bffRuntime.js';
+export type * from './serverTelemetry.js';