@bleedingdev/modern-js-server-core 3.9.0-ultramodern.4 → 3.9.0-ultramodern.5

package/dist/esm-node/adapters/node/plugins/staticModuleFederation.mjs

@@ -1,105 +0,0 @@
-import "node:module";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { fs } from "@modern-js/utils";
-import path from "path";
-const MODULE_FEDERATION_MANIFEST_FILE = 'mf-manifest.json';
-const BACKEND_MODULE_FEDERATION_MANIFEST_FILE = 'backend-mf-manifest.json';
-const MODULE_FEDERATION_MANIFEST_FILES = [
-    MODULE_FEDERATION_MANIFEST_FILE,
-    BACKEND_MODULE_FEDERATION_MANIFEST_FILE
-];
-const MODULE_FEDERATION_OPTIONAL_FILES = [
-    'mf-stats.json'
-];
-const trimLeadingSlash = (value)=>value.replace(/^\/+/, '');
-const getModuleFederationRequestPath = (pathname, pathPrefix)=>{
-    const normalizedPrefix = `/${trimLeadingSlash(pathPrefix)}`.replace(/\/+$/u, '');
-    const requestPath = normalizedPrefix && (pathname === normalizedPrefix || pathname.startsWith(`${normalizedPrefix}/`)) ? pathname.slice(normalizedPrefix.length) : pathname;
-    return trimLeadingSlash(requestPath);
-};
-const isModuleFederationManifestRequest = (requestPath)=>MODULE_FEDERATION_MANIFEST_FILES.includes(requestPath);
-const isBackendModuleFederationManifestRequest = (requestPath)=>requestPath === BACKEND_MODULE_FEDERATION_MANIFEST_FILE;
-const applyModuleFederationAssetHeaders = (c)=>{
-    c.header('Access-Control-Allow-Origin', '*');
-    c.header('Access-Control-Allow-Headers', '*');
-    c.header('Access-Control-Allow-Methods', 'GET,HEAD,OPTIONS');
-};
-const joinModuleFederationAssetPath = (assetPath, assetName)=>{
-    if (!assetName) return '';
-    return trimLeadingSlash(path.posix.join(assetPath || '', assetName));
-};
-const appendModuleFederationAsset = (set, assetPath)=>{
-    if (assetPath) set.add(trimLeadingSlash(assetPath));
-};
-const appendModuleFederationAssets = (set, assets)=>{
-    assets?.js?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
-    assets?.js?.async?.forEach((asset)=>appendModuleFederationAsset(set, asset));
-    assets?.css?.sync?.forEach((asset)=>appendModuleFederationAsset(set, asset));
-    assets?.css?.async?.forEach((asset)=>appendModuleFederationAsset(set, asset));
-};
-const hasAbsoluteProtocol = (value)=>/^https?:\/\//i.test(value) || value.startsWith('//');
-const ensureLeadingSlash = (value)=>{
-    if ('' === value) return '/';
-    return value.startsWith('/') ? value : `/${value}`;
-};
-const ensureTrailingSlash = (value)=>value.endsWith('/') ? value : `${value}/`;
-const patchModuleFederationManifestPublicPath = (c, manifestBuffer, pathPrefix)=>{
-    try {
-        const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
-        const publicPath = manifest.metaData?.publicPath;
-        if (!publicPath || hasAbsoluteProtocol(publicPath)) return manifestBuffer;
-        const requestURL = new URL(c.req.url);
-        const prefixPath = ensureTrailingSlash(ensureLeadingSlash(pathPrefix || '/'));
-        manifest.metaData = {
-            ...manifest.metaData,
-            publicPath: `${requestURL.origin}${prefixPath}`
-        };
-        return Buffer.from(JSON.stringify(manifest), 'utf-8');
-    } catch  {
-        return manifestBuffer;
-    }
-};
-const patchModuleFederationRemoteEntryPublicPath = (c, remoteEntryBuffer, pathPrefix)=>{
-    const requestURL = new URL(c.req.url);
-    const prefixPath = ensureTrailingSlash(ensureLeadingSlash(pathPrefix || '/'));
-    const publicPath = `${requestURL.origin}${prefixPath}`;
-    const source = remoteEntryBuffer.toString('utf-8');
-    const patched = source.replace(/__webpack_require__\.p\s*=\s*(['"`])[^'"`]*\1;/, `__webpack_require__.p = ${JSON.stringify(publicPath)};`).replace(/__rspack_require__\.p\s*=\s*(['"`])[^'"`]*\1;/, `__rspack_require__.p = ${JSON.stringify(publicPath)};`);
-    if (patched === source) return remoteEntryBuffer;
-    return Buffer.from(patched, 'utf-8');
-};
-const getModuleFederationAssetList = async (pwd)=>{
-    const assets = new Set();
-    const remoteEntries = new Set();
-    let manifestFound = false;
-    for (const manifestFile of MODULE_FEDERATION_MANIFEST_FILES){
-        const manifestPath = path.join(pwd, manifestFile);
-        if (!await fs.pathExists(manifestPath)) continue;
-        manifestFound = true;
-        assets.add(manifestFile);
-        const manifestBuffer = await fileReader.readFileFromSystem(manifestPath, 'buffer');
-        if (null !== manifestBuffer) try {
-            const manifest = JSON.parse(manifestBuffer.toString('utf-8'));
-            const remoteEntry = joinModuleFederationAssetPath(manifest.metaData?.remoteEntry?.path, manifest.metaData?.remoteEntry?.name);
-            const dtsZip = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.zip);
-            const dtsApi = joinModuleFederationAssetPath(manifest.metaData?.types?.path, manifest.metaData?.types?.api);
-            if (remoteEntry) {
-                assets.add(remoteEntry);
-                remoteEntries.add(remoteEntry);
-            }
-            appendModuleFederationAsset(assets, dtsZip);
-            appendModuleFederationAsset(assets, dtsApi);
-            manifest.shared?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-            manifest.remotes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-            manifest.exposes?.forEach((item)=>appendModuleFederationAssets(assets, item.assets));
-        } catch  {}
-    }
-    if (manifestFound) {
-        for (const filename of MODULE_FEDERATION_OPTIONAL_FILES)if (await fs.pathExists(path.join(pwd, filename))) assets.add(filename);
-    }
-    return {
-        assets,
-        remoteEntries
-    };
-};
-export { MODULE_FEDERATION_MANIFEST_FILE, applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isBackendModuleFederationManifestRequest, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath };

package/dist/esm-node/adapters/node/plugins/staticPrecompressed.mjs

@@ -1,112 +0,0 @@
-import "node:module";
-import { fs } from "@modern-js/utils";
-const PRE_COMPRESSED_ASSET_EXTENSIONS = {
-    br: '.br',
-    gzip: '.gz'
-};
-const PRE_COMPRESSED_SUPPORTED_ENCODINGS = [
-    'br',
-    'gzip'
-];
-const QUALITY_VALUE_PATTERN = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/u;
-const parseAcceptEncoding = (value)=>value.split(',').map((item)=>item.trim()).filter(Boolean).map((item)=>{
-        const [rawName, ...params] = item.split(';');
-        const name = rawName.trim().toLowerCase();
-        let q = 1;
-        let qualitySeen = false;
-        for (const param of params){
-            const [key, rawValue] = param.split('=').map((v)=>v.trim());
-            if ('q' === key.toLowerCase()) {
-                if (qualitySeen || null == rawValue || !QUALITY_VALUE_PATTERN.test(rawValue)) {
-                    q = 0;
-                    break;
-                }
-                qualitySeen = true;
-                q = Number(rawValue);
-            }
-        }
-        return {
-            name,
-            q
-        };
-    });
-const getAcceptedRepresentations = (value)=>{
-    if (!value) return [
-        'identity'
-    ];
-    const parsed = parseAcceptEncoding(value);
-    const qualityByEncoding = new Map();
-    let wildcardQuality;
-    for (const { name, q } of parsed){
-        if ('*' === name) {
-            wildcardQuality = q;
-            continue;
-        }
-        qualityByEncoding.set(name, q);
-    }
-    const getQuality = (encoding)=>{
-        const explicit = qualityByEncoding.get(encoding);
-        if (void 0 !== explicit) return explicit;
-        return wildcardQuality ?? 0;
-    };
-    const identityQuality = qualityByEncoding.get('identity') ?? (0 === wildcardQuality ? 0 : 1);
-    return [
-        ...PRE_COMPRESSED_SUPPORTED_ENCODINGS.map((encoding)=>({
-                encoding,
-                quality: getQuality(encoding)
-            })),
-        {
-            encoding: 'identity',
-            quality: identityQuality
-        }
-    ].filter((item)=>item.quality > 0).sort((a, b)=>b.quality - a.quality).map((item)=>item.encoding);
-};
-const appendVaryHeader = (c, value)=>{
-    const current = c.res.headers.get('Vary');
-    if (!current) return void c.header('Vary', value);
-    const values = current.split(',').map((item)=>item.trim().toLowerCase()).filter(Boolean);
-    if (!values.includes(value.toLowerCase())) c.header('Vary', `${current}, ${value}`);
-};
-const resolvePreCompressedAsset = async (c, filepath)=>{
-    const brPath = `${filepath}${PRE_COMPRESSED_ASSET_EXTENSIONS.br}`;
-    const gzipPath = `${filepath}${PRE_COMPRESSED_ASSET_EXTENSIONS.gzip}`;
-    const [hasBr, hasGzip] = await Promise.all([
-        fs.pathExists(brPath),
-        fs.pathExists(gzipPath)
-    ]);
-    const hasVariant = hasBr || hasGzip;
-    const acceptedRepresentations = getAcceptedRepresentations(c.req.header('accept-encoding'));
-    for (const encoding of acceptedRepresentations){
-        if ('identity' === encoding) return {
-            selected: null,
-            hasVariant,
-            acceptable: true
-        };
-        if ('br' === encoding && hasBr) return {
-            selected: {
-                filepath: brPath,
-                encoding
-            },
-            hasVariant: true,
-            acceptable: true
-        };
-        if ('gzip' === encoding && hasGzip) return {
-            selected: {
-                filepath: gzipPath,
-                encoding
-            },
-            hasVariant: true,
-            acceptable: true
-        };
-    }
-    return {
-        selected: null,
-        hasVariant,
-        acceptable: false
-    };
-};
-const applyPreCompressedAssetHeaders = (c, preCompressedAsset)=>{
-    if (preCompressedAsset.hasVariant || !preCompressedAsset.acceptable) appendVaryHeader(c, 'Accept-Encoding');
-    if (preCompressedAsset.selected) c.header('Content-Encoding', preCompressedAsset.selected.encoding);
-};
-export { applyPreCompressedAssetHeaders, resolvePreCompressedAsset };

package/dist/esm-node/adapters/node/plugins/staticServing.mjs

@@ -1,153 +0,0 @@
-import "node:module";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { fs } from "@modern-js/utils";
-import { getMimeType } from "hono/utils/mime";
-import path from "path";
-import { applyModuleFederationAssetHeaders, getModuleFederationAssetList, getModuleFederationRequestPath, isBackendModuleFederationManifestRequest, isModuleFederationManifestRequest, patchModuleFederationManifestPublicPath, patchModuleFederationRemoteEntryPublicPath } from "./staticModuleFederation.mjs";
-import { applyPreCompressedAssetHeaders, resolvePreCompressedAsset } from "./staticPrecompressed.mjs";
-const MODULE_FEDERATION_ASSET_REFRESH_INTERVAL_MS = 1000;
-const getStaticMimeType = (filename)=>getMimeType(filename) ?? ('.cjs' === path.extname(filename).toLowerCase() ? "text/javascript; charset=UTF-8" : void 0);
-const servePreCompressedPublicRouteAsset = async (c, pwd, route)=>{
-    const { entryPath } = route;
-    const originFilename = path.join(pwd, entryPath);
-    const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
-    if (!preCompressedAsset.acceptable) {
-        applyPreCompressedAssetHeaders(c, preCompressedAsset);
-        return c.body(null, 406);
-    }
-    const filename = preCompressedAsset.selected?.filepath ?? originFilename;
-    const data = await fileReader.readFile(filename, 'buffer');
-    const mimeType = getStaticMimeType(originFilename);
-    if (null === data) return null;
-    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    if (mimeType) c.header('Content-Type', mimeType);
-    Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
-        c.header(k, v);
-    });
-    applyPreCompressedAssetHeaders(c, preCompressedAsset);
-    c.header('Content-Length', String(data.byteLength));
-    return c.body(body, 200);
-};
-const isPathInside = (target, root)=>{
-    const relative = path.relative(path.resolve(root), path.resolve(target));
-    return '' === relative || !relative.startsWith(`..${path.sep}`) && '..' !== relative && !path.isAbsolute(relative);
-};
-const resolvePublicDirectoryAsset = async (pwd, pathname)=>{
-    let decodedPathname;
-    try {
-        decodedPathname = decodeURIComponent(pathname).replace(/\\/gu, '/');
-    } catch  {
-        return null;
-    }
-    if (decodedPathname.includes('\0') || decodedPathname.split('/').includes('..')) return null;
-    const publicDirectory = path.join(pwd, 'public');
-    const filepath = path.resolve(publicDirectory, decodedPathname.replace(/^\/+/u, ''));
-    if (!isPathInside(filepath, publicDirectory)) return null;
-    try {
-        const [realPublicDirectory, realFilepath, stat] = await Promise.all([
-            fs.realpath(publicDirectory),
-            fs.realpath(filepath),
-            fs.stat(filepath)
-        ]);
-        if (!stat.isFile() || !isPathInside(realFilepath, realPublicDirectory)) return null;
-        return realFilepath;
-    } catch  {
-        return null;
-    }
-};
-const servePublicDirectoryAsset = async (c, pwd)=>{
-    const method = c.req.raw.method.toUpperCase();
-    if ('GET' !== method && 'HEAD' !== method) return null;
-    const originFilename = await resolvePublicDirectoryAsset(pwd, c.req.path);
-    if (null === originFilename) return null;
-    const preCompressedAsset = await resolvePreCompressedAsset(c, originFilename);
-    if (!preCompressedAsset.acceptable) {
-        applyPreCompressedAssetHeaders(c, preCompressedAsset);
-        return c.body(null, 406);
-    }
-    const selectedFilename = preCompressedAsset.selected?.filepath ?? originFilename;
-    const publicDirectory = await fs.realpath(path.join(pwd, 'public'));
-    let realSelectedFilename;
-    try {
-        realSelectedFilename = await fs.realpath(selectedFilename);
-    } catch  {
-        return null;
-    }
-    if (!isPathInside(realSelectedFilename, publicDirectory)) return null;
-    const data = await fileReader.readFileFromSystem(realSelectedFilename, 'buffer');
-    if (null === data) return null;
-    const mimeType = getStaticMimeType(originFilename);
-    if (mimeType) c.header('Content-Type', mimeType);
-    applyPreCompressedAssetHeaders(c, preCompressedAsset);
-    c.header('Content-Length', String(data.byteLength));
-    if ('HEAD' === method) return c.body(null, 200);
-    const body = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    return c.body(body, 200);
-};
-const createModuleFederationStaticServing = ({ pwd, pathPrefix })=>{
-    let moduleFederationAssets = null;
-    let moduleFederationAssetsExpiresAt = 0;
-    let moduleFederationAssetsRefresh = null;
-    const getModuleFederationAssets = async ()=>{
-        if (moduleFederationAssets && Date.now() < moduleFederationAssetsExpiresAt) return moduleFederationAssets;
-        if (!moduleFederationAssetsRefresh) moduleFederationAssetsRefresh = getModuleFederationAssetList(pwd).then((assets)=>{
-            moduleFederationAssets = assets;
-            moduleFederationAssetsExpiresAt = Date.now() + MODULE_FEDERATION_ASSET_REFRESH_INTERVAL_MS;
-            return assets;
-        }).finally(()=>{
-            moduleFederationAssetsRefresh = null;
-        });
-        return moduleFederationAssetsRefresh;
-    };
-    const resolveRequest = async (pathname)=>{
-        const requestPath = getModuleFederationRequestPath(pathname, pathPrefix);
-        if (requestPath.includes('..')) return null;
-        const moduleFederationAssetMeta = await getModuleFederationAssets();
-        return {
-            requestPath,
-            isModuleFederationAsset: moduleFederationAssetMeta.assets.has(requestPath),
-            isModuleFederationRemoteEntry: moduleFederationAssetMeta.remoteEntries.has(requestPath)
-        };
-    };
-    const serveFile = async (c, filepath, moduleFederationAsset = false, moduleFederationRemoteEntry = false, requestPath = '')=>{
-        if (moduleFederationAsset) applyModuleFederationAssetHeaders(c);
-        const mimeType = getStaticMimeType(filepath);
-        if (mimeType) c.header('Content-Type', mimeType);
-        const shouldPatchManifest = moduleFederationAsset && isModuleFederationManifestRequest(requestPath) && !isBackendModuleFederationManifestRequest(requestPath);
-        const shouldPatchRemoteEntry = moduleFederationRemoteEntry;
-        const canUsePreCompressed = !shouldPatchManifest && !shouldPatchRemoteEntry;
-        const preCompressedAsset = canUsePreCompressed ? await resolvePreCompressedAsset(c, filepath) : {
-            selected: null,
-            hasVariant: false,
-            acceptable: true
-        };
-        if (!preCompressedAsset.acceptable) {
-            applyPreCompressedAssetHeaders(c, preCompressedAsset);
-            return c.body(null, 406);
-        }
-        const targetFilepath = preCompressedAsset.selected?.filepath ?? filepath;
-        const chunk = await fileReader.readFileFromSystem(targetFilepath, 'buffer');
-        if (null === chunk) return null;
-        const responseChunk = shouldPatchManifest ? patchModuleFederationManifestPublicPath(c, chunk, pathPrefix) : shouldPatchRemoteEntry ? patchModuleFederationRemoteEntryPublicPath(c, chunk, pathPrefix) : chunk;
-        applyPreCompressedAssetHeaders(c, preCompressedAsset);
-        c.header('Content-Length', String(responseChunk.byteLength));
-        const body = new Uint8Array(responseChunk.buffer, responseChunk.byteOffset, responseChunk.byteLength);
-        return c.body(body, 200);
-    };
-    const serveByPath = async (c, filepath, request, moduleFederationAsset = false, moduleFederationRemoteEntry = false)=>{
-        if (!isPathInside(filepath, pwd)) return null;
-        if (!await fs.pathExists(filepath)) return null;
-        return serveFile(c, filepath, moduleFederationAsset, moduleFederationRemoteEntry, request.requestPath);
-    };
-    const serveStaticHit = (c, request)=>serveByPath(c, path.join(pwd, request.requestPath), request, request.isModuleFederationAsset, request.isModuleFederationRemoteEntry);
-    const serveModuleFederationAsset = (c, request)=>{
-        if (!request.isModuleFederationAsset) return null;
-        return serveByPath(c, path.join(pwd, request.requestPath), request, true, request.isModuleFederationRemoteEntry);
-    };
-    return {
-        resolveRequest,
-        serveStaticHit,
-        serveModuleFederationAsset
-    };
-};
-export { createModuleFederationStaticServing, servePreCompressedPublicRouteAsset, servePublicDirectoryAsset };

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

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

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

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

package/dist/types/adapters/node/plugins/staticModuleFederation.d.ts

@@ -1,13 +0,0 @@
-import type { Middleware } from '../../../types/index.js';
-export declare const MODULE_FEDERATION_MANIFEST_FILE = "mf-manifest.json";
-export type ModuleFederationServeAssets = {
-    assets: Set<string>;
-    remoteEntries: Set<string>;
-};
-export declare const getModuleFederationRequestPath: (pathname: string, pathPrefix: string) => string;
-export declare const isModuleFederationManifestRequest: (requestPath: string) => boolean;
-export declare const isBackendModuleFederationManifestRequest: (requestPath: string) => requestPath is "backend-mf-manifest.json";
-export declare const applyModuleFederationAssetHeaders: (c: Parameters<Middleware>[0]) => void;
-export declare const patchModuleFederationManifestPublicPath: (c: Parameters<Middleware>[0], manifestBuffer: Buffer, pathPrefix: string) => Buffer<ArrayBufferLike>;
-export declare const patchModuleFederationRemoteEntryPublicPath: (c: Parameters<Middleware>[0], remoteEntryBuffer: Buffer, pathPrefix: string) => Buffer<ArrayBufferLike>;
-export declare const getModuleFederationAssetList: (pwd: string) => Promise<ModuleFederationServeAssets>;

package/dist/types/adapters/node/plugins/staticPrecompressed.d.ts

@@ -1,13 +0,0 @@
-import type { Middleware } from '../../../types/index.js';
-type SupportedEncoding = 'br' | 'gzip';
-type ResolvePreCompressedAssetResult = {
-    selected: {
-        filepath: string;
-        encoding: SupportedEncoding;
-    } | null;
-    hasVariant: boolean;
-    acceptable: boolean;
-};
-export declare const resolvePreCompressedAsset: (c: Parameters<Middleware>[0], filepath: string) => Promise<ResolvePreCompressedAssetResult>;
-export declare const applyPreCompressedAssetHeaders: (c: Parameters<Middleware>[0], preCompressedAsset: ResolvePreCompressedAssetResult) => void;
-export {};

package/dist/types/adapters/node/plugins/staticServing.d.ts

@@ -1,25 +0,0 @@
-import type { ServerRoute } from '@modern-js/types';
-import type { Middleware } from '../../../types/index.js';
-type MiddlewareContext = Parameters<Middleware>[0];
-type StaticServingRequest = {
-    requestPath: string;
-    isModuleFederationAsset: boolean;
-    isModuleFederationRemoteEntry: boolean;
-};
-type StaticServingOptions = {
-    pwd: string;
-    pathPrefix: string;
-};
-export declare const servePreCompressedPublicRouteAsset: (c: MiddlewareContext, pwd: string, route: ServerRoute) => Promise<(Response & import("hono").TypedResponse<null, 406, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
-/**
- * Serves post-build convention assets generated under dist/public at their
- * root URL. This is intentionally independent of config/public and route.json:
- * the generator runs after the route manifest is built.
- */
-export declare const servePublicDirectoryAsset: (c: MiddlewareContext, pwd: string) => Promise<(Response & import("hono").TypedResponse<null, 200, "body">) | (Response & import("hono").TypedResponse<null, 406, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
-export declare const createModuleFederationStaticServing: ({ pwd, pathPrefix, }: StaticServingOptions) => {
-    resolveRequest: (pathname: string) => Promise<StaticServingRequest | null>;
-    serveStaticHit: (c: MiddlewareContext, request: StaticServingRequest) => Promise<(Response & import("hono").TypedResponse<null, 406, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null>;
-    serveModuleFederationAsset: (c: MiddlewareContext, request: StaticServingRequest) => Promise<(Response & import("hono").TypedResponse<null, 406, "body">) | (Response & import("hono").TypedResponse<Uint8Array<ArrayBuffer>, 200, "body">) | null> | null;
-};
-export {};

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

@@ -1,116 +0,0 @@
-export type BffRuntimeFramework = 'hono' | 'effect';
-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.
-     *
-     * When enabled, 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 treated as legacy escape hatches.
-     *
-     * @default true
-     */
-    strictEffectApproach?: true;
-    openapi?: BffEffectOpenApiUserConfig;
-    dataPlatform?: BffEffectDataPlatformUserConfig;
-}