@bleedingdev/modern-js-plugin-bff 3.8.2-ultramodern.9 → 3.8.3-ultramodern.2

package/dist/types/runtime/effect/handler/batch.d.ts

@@ -1,13 +0,0 @@
-import { type DataBatchRequestPayload, type DataBatchResponseItem } from '../../data-platform';
-export { toHeaderRecord } from '../../../utils/headers';
-export declare function normalizeBatchPath(pathname: string | undefined): `/${string}`;
-export declare function normalizeBatchAllowedMethods(allowedMethods: string[] | undefined): Set<string>;
-type ParsedBatchRequestPayload = Omit<DataBatchRequestPayload, 'items'> & {
-    items: unknown[];
-};
-export declare function isBatchRequestPayload(value: unknown): value is ParsedBatchRequestPayload;
-export declare function createBatchValidationResponse(message: string, status?: number): Response;
-export declare function prepareJsonRequestBody(request: Request): Promise<Request | Response>;
-export declare function toBatchItemError(id: string, status: number, message: string): DataBatchResponseItem;
-export declare function promiseWithTimeout<T>(effect: Promise<T>, timeoutMs: number): Promise<T>;
-export declare function mapWithConcurrency<TItem, TResult>(items: readonly TItem[], concurrency: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;

package/dist/types/runtime/effect/handler/definition.d.ts

@@ -1,7 +0,0 @@
-import type { HttpApi } from 'effect/unstable/httpapi';
-import type { Rpc } from 'effect/unstable/rpc';
-import type { EffectBffDefinition, EffectBffRuntime, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcRuntimeLayer, EffectRuntimeLayer } from './types';
-export declare function defineEffectBff<TApi extends HttpApi.Constraint, TLayer extends EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any>(definition: EffectBffDefinition<TApi, TLayer, TRpcs>): EffectBffDefinition<TApi, TLayer, TRpcs> & EffectBffRuntime<TApi, TLayer>;
-export declare function defineEffectRpcBff<TRpcs extends Rpc.Any = Rpc.Any, TLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>>(definition: EffectRpcBffDefinition<TRpcs, TLayer>): EffectRpcBffDefinition<TRpcs, TLayer> & {
-    createHandler: EffectRpcBffHandlerFactory<TRpcs>;
-};

package/dist/types/runtime/effect/handler/envelope.d.ts

@@ -1,13 +0,0 @@
-import type { EffectDataPlatformValidationOptions } from './types';
-/**
- * Validates the `x-modernjs-data-envelope` header (the data-platform
- * transport/cache contract: protocol version, scope, selection plan).
- *
- * This is NOT a security boundary: the envelope is client-constructed cache
- * metadata used for batching, scope keys and hydration. Cross-project
- * authorization runs through the bff-core policy evaluator wired in via
- * `validateRequest` (see `EffectRequestValidator`), which both the direct
- * and batched request paths hit before this check.
- */
-export declare function validateDataPlatformRequestEnvelope(request: Request, options: EffectDataPlatformValidationOptions | undefined): Response | null;
-export declare function mergeDataPlatformOptions(base: EffectDataPlatformValidationOptions | undefined, override: Partial<EffectDataPlatformValidationOptions> | undefined): EffectDataPlatformValidationOptions | undefined;

package/dist/types/runtime/effect/handler/http.d.ts

@@ -1,15 +0,0 @@
-import type { HttpApi } from 'effect/unstable/httpapi';
-import type { Rpc } from 'effect/unstable/rpc';
-import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestInterceptor, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types';
-export declare function createHttpApiHandler<TApi extends HttpApi.Constraint = HttpApi.Top, TRpcs extends Rpc.Any = Rpc.Any>(options: {
-    api: TApi;
-    layer: EffectRuntimeLayer;
-    openapi?: EffectBffOpenApiConfig;
-    rpc?: EffectRpcBffDefinition<TRpcs>;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-    interceptRequest?: EffectRequestInterceptor;
-    validateRequest?: EffectRequestValidator;
-}): {
-    handler: (request: Request, context?: Parameters<(request: globalThis.Request, context: import("effect/Context").Context<unknown>) => Promise<Response>>[1]) => Promise<Response>;
-    dispose: () => Promise<void>;
-};

package/dist/types/runtime/effect/handler/openapi.d.ts

@@ -1,4 +0,0 @@
-import { HttpRouter } from 'effect/unstable/http';
-import { type HttpApi } from 'effect/unstable/httpapi';
-import type { EffectBffOpenApiConfig } from './types';
-export declare function createOpenApiLayer(api: HttpApi.Constraint, openapi: EffectBffOpenApiConfig | undefined): import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter> | null;

package/dist/types/runtime/effect/handler/routing.d.ts

@@ -1,5 +0,0 @@
-export declare function getRequestPathname(request: Request): string;
-export declare function getMountedPrefixFromContext(request: Request, context: unknown): string;
-export declare function removeMountedPrefixFromBatchPath(pathWithQuery: string, prefix: string): string;
-export declare function getExpectedEnvelopeOrigin(request: Request): string;
-export declare function isRpcRequest(request: Request, rpcPath: `/${string}`): boolean;

package/dist/types/runtime/effect/handler/rpc.d.ts

@@ -1,7 +0,0 @@
-import { type Rpc } from 'effect/unstable/rpc';
-import type { EffectRpcBffDefinition } from './types';
-export declare function normalizeRpcPath(pathname: string | undefined): `/${string}`;
-export declare function createRpcApiHandler<TRpcs extends Rpc.Any = Rpc.Any>(options: EffectRpcBffDefinition<TRpcs>): {
-    readonly handler: (request: globalThis.Request, context?: import("effect/Context").Context<never> | undefined) => Promise<Response>;
-    readonly dispose: () => Promise<void>;
-};

package/dist/types/runtime/effect/handler/types.d.ts

@@ -1,153 +0,0 @@
-import type { FileSystem, Path } from 'effect';
-import * as Context from 'effect/Context';
-import type * as EffectType from 'effect/Effect';
-import type * as Layer from 'effect/Layer';
-import type { Etag, HttpPlatform, HttpRouter } from 'effect/unstable/http';
-import type { HttpApi, HttpApiClient, HttpApiGroup } from 'effect/unstable/httpapi';
-import type { Rpc, RpcGroup } from 'effect/unstable/rpc';
-import type { createHttpApiHandler } from './http';
-import type { createRpcApiHandler } from './rpc';
-export type EffectRuntimeRequirements = Etag.Generator | FileSystem.FileSystem | HttpPlatform.HttpPlatform | HttpRouter.HttpRouter | HttpRouter.Request<'Error', unknown> | HttpRouter.Request<'GlobalError', unknown> | HttpRouter.Request<'GlobalRequires', unknown> | HttpRouter.Request<'Requires', unknown> | Path.Path;
-export type EffectRuntimeLayer = Layer.Layer<never, never, EffectRuntimeRequirements>;
-export declare const toEffectServiceContext: (context: unknown) => Context.Context<any>;
-export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
-export type EffectRpcRuntimeLayer<TRpcs extends Rpc.Any = Rpc.Any> = Layer.Layer<Rpc.ToHandler<TRpcs> | Rpc.Middleware<TRpcs> | Rpc.ServicesServer<TRpcs>, unknown, never>;
-export type EffectRpcBffDefinition<TRpcs extends Rpc.Any = Rpc.Any, TRpcLayer extends EffectRpcRuntimeLayer<TRpcs> = EffectRpcRuntimeLayer<TRpcs>> = {
-    group: RpcGroup.RpcGroup<TRpcs>;
-    layer: TRpcLayer;
-    path?: `/${string}`;
-    serialization?: EffectRpcSerialization;
-    disableTracing?: boolean;
-    spanPrefix?: string;
-    spanAttributes?: Record<string, unknown>;
-    disableFatalDefects?: boolean;
-};
-export type EffectRpcBffHandlerOptions = Pick<EffectRpcBffDefinition, 'path' | 'serialization' | 'disableTracing' | 'spanPrefix' | 'spanAttributes' | 'disableFatalDefects'>;
-type EffectApiPromiseClient<TClient> = {
-    [GroupName in keyof TClient]: {
-        [EndpointName in keyof TClient[GroupName]]: TClient[GroupName][EndpointName] extends (...args: infer TArgs) => infer TResult ? TResult extends EffectType.Effect<unknown, unknown, unknown> ? (...args: TArgs) => Promise<Exclude<EffectType.Success<TResult>, readonly [unknown, unknown]>> : never : never;
-    };
-};
-export type EffectApiClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Constraint>, never, never> : never;
-export type EffectApiPromiseClientFromApi<TApi extends HttpApi.Constraint = HttpApi.Top> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
-export type EffectBffDefinition<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
-    api: TApi;
-    layer: TLayer;
-    rpc?: EffectRpcBffDefinition<TRpcs>;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-    interceptRequest?: EffectRequestInterceptor;
-};
-export type EffectDataPlatformSelectionValidationOptions = {
-    maxDepth?: number;
-    maxFields?: number;
-    allowedLeafPaths?: string[];
-};
-export type EffectDataPlatformBatchOptions = {
-    /**
-     * Enable network batching endpoint for Effect HttpApi requests.
-     * Defaults to `true`.
-     */
-    enabled?: boolean;
-    /**
-     * Batch endpoint path mounted under BFF prefix.
-     * Defaults to `/_data/batch`.
-     */
-    endpoint?: `/${string}`;
-    /**
-     * Maximum request items accepted per batch call.
-     * Defaults to `16`.
-     */
-    maxBatchSize?: number;
-    /**
-     * Maximum serialized request payload size in bytes.
-     * Defaults to `65536` (64KiB).
-     */
-    maxBatchBytes?: number;
-    /**
-     * Client-side micro-batch flush window in milliseconds.
-     * Server runtime ignores this value and passes it through for codegen.
-     * Defaults to `8`.
-     */
-    flushIntervalMs?: number;
-    /**
-     * Maximum per-batch internal request concurrency.
-     * Defaults to `4`.
-     */
-    maxConcurrency?: number;
-    /**
-     * Optional timeout per internal request in milliseconds.
-     * Defaults to `10000`.
-     */
-    requestTimeoutMs?: number;
-    /**
-     * Allowed HTTP methods for internal batched dispatch.
-     * Defaults to `['GET']`.
-     */
-    allowedMethods?: string[];
-};
-export type EffectDataPlatformValidationOptions = {
-    /**
-     * Enable envelope validation for HttpApi requests.
-     * Defaults to `true`.
-     */
-    enabled?: boolean;
-    /**
-     * Require every HttpApi request to include an envelope header.
-     * Defaults to `false`.
-     */
-    requireEnvelope?: boolean;
-    /**
-     * Header name used by client/server for the serialized request envelope.
-     * Defaults to `x-modernjs-data-envelope`.
-     */
-    envelopeHeader?: string;
-    /**
-     * Optional namespace assertion for envelope validation.
-     */
-    expectedNamespace?: string;
-    /**
-     * Validate envelope origin against incoming request origin.
-     * Defaults to `true`.
-     */
-    validateOrigin?: boolean;
-    /**
-     * Require trace context inside request envelope.
-     * Defaults to `false`.
-     */
-    requireTraceContext?: boolean;
-    /**
-     * Selection plan guardrails for server-side validation.
-     */
-    selection?: EffectDataPlatformSelectionValidationOptions;
-    /**
-     * Network batching gateway configuration.
-     */
-    batch?: EffectDataPlatformBatchOptions;
-};
-/**
- * Server-seam request validator applied to every HttpApi request — direct,
- * batched (per item) and rpc. Returning a Response short-circuits the
- * request; returning `null`/`undefined` lets it through. Used by the effect
- * adapter to enforce the cross-project policy at one seam so batched items
- * cannot bypass it.
- */
-export type EffectRequestValidator = (request: Request) => Response | null | undefined;
-export type EffectRequestInterceptor = (options: {
-    request: Request;
-    next: () => Promise<Response>;
-}) => Response | Promise<Response>;
-export type EffectBffHandlerFactory<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
-    openapi?: EffectBffOpenApiConfig;
-    rpc?: Partial<EffectRpcBffHandlerOptions>;
-    dataPlatform?: Partial<EffectDataPlatformValidationOptions>;
-    validateRequest?: EffectRequestValidator;
-}) => ReturnType<typeof createHttpApiHandler>;
-export type EffectBffRuntime<TApi extends HttpApi.Constraint = HttpApi.Top, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = {
-    createHandler: EffectBffHandlerFactory<TApi, TLayer>;
-    client: EffectApiPromiseClientFromApi<TApi>;
-};
-export type EffectBffOpenApiConfig = boolean | {
-    path?: string;
-};
-export type EffectRpcBffHandlerFactory<TRpcs extends Rpc.Any = Rpc.Any> = (options?: Partial<EffectRpcBffHandlerOptions>) => ReturnType<typeof createRpcApiHandler<TRpcs>>;
-export {};

package/dist/types/runtime/effect/handler.d.ts

@@ -1,14 +0,0 @@
-export * as Config from 'effect/Config';
-export * as Effect from 'effect/Effect';
-export * as Layer from 'effect/Layer';
-export * as Option from 'effect/Option';
-export * as Schema from 'effect/Schema';
-export * from 'effect/unstable/http';
-export { HttpTraceContext } from 'effect/unstable/http';
-export * from 'effect/unstable/httpapi';
-export { HttpApiBuilder } from 'effect/unstable/httpapi';
-export * from 'effect/unstable/rpc';
-export { EFFECT_VALIDATOR_AWARE_FACTORY, isValidatorAwareHandlerFactory, } from './entry-shape';
-export { defineEffectBff, defineEffectRpcBff } from './handler/definition';
-export { createHttpApiHandler } from './handler/http';
-export type { EffectApiClientFromApi, EffectApiPromiseClientFromApi, EffectBffDefinition, EffectBffHandlerFactory, EffectBffOpenApiConfig, EffectBffRuntime, EffectDataPlatformBatchOptions, EffectDataPlatformSelectionValidationOptions, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRpcBffHandlerFactory, EffectRpcBffHandlerOptions, EffectRpcRuntimeLayer, EffectRpcSerialization, EffectRuntimeLayer, EffectRuntimeRequirements, } from './handler/types';

package/dist/types/runtime/effect/module.d.ts

@@ -1,36 +0,0 @@
-import type * as EffectServiceContext from 'effect/Context';
-import { type EffectBffOpenApiConfig, type EffectDataPlatformValidationOptions, type EffectRequestValidator } from './handler';
-import type { EffectContext } from './operation-context';
-export type EffectBffRequestHandler = (request: Request, context?: EffectServiceContext.Context<any> | EffectContext) => Promise<Response> | Response;
-export type EffectBffHandlerFactory = (options?: {
-    openapi?: EffectBffOpenApiConfig;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-    validateRequest?: EffectRequestValidator;
-}) => {
-    handler: EffectBffRequestHandler;
-    dispose: () => Promise<void>;
-};
-export type EffectApiModule = {
-    api?: unknown;
-    layer?: unknown;
-    handler?: EffectBffRequestHandler;
-    createHandler?: EffectBffHandlerFactory;
-    default?: unknown;
-};
-type LoadedEffectBffHandler = {
-    handler: EffectBffRequestHandler;
-    dispose?: () => Promise<void>;
-};
-type ResolveEffectBffModuleHandlerOptions = {
-    openapi?: EffectBffOpenApiConfig;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-    /**
-     * Server-seam request validator (cross-project policy). Strict Effect
-     * entries forward it into `createHttpApiHandler`, where it applies to
-     * direct, batched and rpc requests.
-     */
-    validateRequest?: EffectRequestValidator;
-    onWarning?: (message: string) => void;
-};
-export declare function resolveEffectBffModuleHandler(mod: EffectApiModule, options?: ResolveEffectBffModuleHandlerOptions): Promise<LoadedEffectBffHandler | null>;
-export {};

package/dist/types/runtime/effect/operation-context.d.ts

@@ -1,10 +0,0 @@
-import { type OperationContext } from '@modern-js/create-request';
-export type EffectContext = {
-    request: Request;
-    env: Record<string, unknown>;
-    path: string;
-    method: string;
-    operationContext: OperationContext;
-};
-export type CreateEffectOperationContextOptions = Omit<EffectContext, 'operationContext'>;
-export declare const createEffectOperationContext: ({ request, path, method, }: CreateEffectOperationContextOptions) => OperationContext;

package/dist/types/runtime/effect/rpcSerialization.d.ts

@@ -1,3 +0,0 @@
-import { RpcSerialization } from 'effect/unstable/rpc';
-import type { EffectRpcSerialization } from './handler/types';
-export declare function getRpcSerializationLayer(serialization: EffectRpcSerialization | undefined): import("effect/Layer").Layer<RpcSerialization.RpcSerialization, never, never>;

package/dist/types/runtime/effect-client/batch.d.ts

@@ -1,2 +0,0 @@
-import type { EffectRequestRuntime, GeneratedEffectClientConfig } from './types';
-export declare const configureGeneratedEffectClientRuntime: (config: GeneratedEffectClientConfig, configureRequest: EffectRequestRuntime['configure'] | undefined) => void;

package/dist/types/runtime/effect-client/envelope.d.ts

@@ -1,15 +0,0 @@
-import type { EffectOperationDescriptor, EffectRequestContext, EffectRequestContextInput, GeneratedEffectClientConfig, GeneratedEffectEndpoint } from './types';
-/**
- * Resolves the current page origin with a configurable fallback. Single
- * implementation shared by the configure() bootstrap and the data envelope
- * (the generated template previously duplicated data-platform's
- * `resolveRuntimeOrigin` with a different fallback).
- */
-export declare const resolveOrigin: (defaultOrigin: string) => string;
-export declare const prepareEffectRequest: (options: {
-    endpoint: GeneratedEffectEndpoint;
-    operation: EffectOperationDescriptor;
-    request: unknown;
-    config: GeneratedEffectClientConfig;
-    createEffectRequestContext: (requestContext: EffectRequestContextInput) => EffectRequestContext;
-}) => Record<string, unknown>;

package/dist/types/runtime/effect-client/guards.d.ts

@@ -1,2 +0,0 @@
-export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
-export declare const stringOrUndefined: (value: unknown) => string | undefined;

package/dist/types/runtime/effect-client/request-context.d.ts

@@ -1,3 +0,0 @@
-import type { EffectRequestContext, EffectRequestContextInput, EffectRequestRuntime } from './types';
-export declare const createEffectRequestContext: (createRequestContextHeaders: EffectRequestRuntime['createRequestContextHeaders'], requestContext: EffectRequestContextInput) => EffectRequestContext;
-export declare const applyRequestContext: (normalizedRequest: Record<string, unknown>, request: unknown, createRequestContext: (requestContext: EffectRequestContextInput) => EffectRequestContext) => Record<string, unknown>;

package/dist/types/runtime/effect-client/request.d.ts

@@ -1 +0,0 @@
-export declare const normalizeRequest: (method: string, request: unknown) => Record<string, unknown>;

package/dist/types/runtime/effect-client/types.d.ts

@@ -1,68 +0,0 @@
-export type GeneratedEffectEndpoint = {
-    apiId: string;
-    group: string;
-    endpoint: string;
-    method: string;
-    routePath: string;
-    /** Per-endpoint operation contract hash (bff-core hash). */
-    schemaHash: string;
-    operationVersion: number;
-};
-export type GeneratedEffectBatchConfig = {
-    enabled: boolean;
-    endpoint: string;
-    flushIntervalMs: number;
-    maxBatchSize: number;
-    maxBatchBytes: number;
-    requestTimeoutMs: number;
-    allowedMethods: string[];
-};
-export type GeneratedEffectClientConfig = {
-    appNamespace: string;
-    /** Cross-project producer id; absent for same-project clients. */
-    requestId?: string;
-    port: number;
-    /** Resolve the port from process.env.PORT first (server bundles). */
-    useEnvPort?: boolean;
-    defaultOrigin: string;
-    httpMethodDecider?: string;
-    batch: GeneratedEffectBatchConfig;
-};
-export type EffectOperationDescriptor = {
-    appNamespace: string;
-    apiId: string;
-    group: string;
-    endpoint: string;
-    operationId: string;
-    routePath: string;
-    method: string;
-    operationVersion: number;
-    schemaHash: string;
-    version: number;
-};
-export type EffectClientOperation = (request?: unknown) => Promise<unknown>;
-export type EffectClientGroup = Record<string, EffectClientOperation>;
-export type EffectClient = Record<string, EffectClientGroup>;
-export type EffectOperationManifest = Record<string, Record<string, EffectOperationDescriptor>>;
-export type EffectRequestContextInput = Record<string, unknown>;
-export type EffectRequestContext = {
-    headers: Record<string, string>;
-} & Record<string, unknown>;
-/** Structural slice of `@modern-js/create-request` the runtime relies on. */
-export type EffectRequestRuntime = {
-    createRequest: (options: {
-        path: string;
-        method: string;
-        port: number | string;
-        operationContext: Record<string, unknown>;
-        httpMethodDecider: string;
-        requestId?: string;
-    }) => (...args: unknown[]) => Promise<unknown>;
-    configure?: (options: Record<string, unknown>) => void;
-    createRequestContextHeaders?: (input: EffectRequestContextInput) => Record<string, string>;
-};
-export type GeneratedEffectClientModule = {
-    client: EffectClient;
-    operationManifest: EffectOperationManifest;
-    createEffectRequestContext: (requestContext: EffectRequestContextInput) => EffectRequestContext;
-};

package/dist/types/runtime/safe-failure.d.ts

@@ -1 +0,0 @@
-export declare const createSafeFailureResponse: (error: unknown) => Response;

package/dist/types/utils/crossProjectServerPolicy.d.ts

@@ -1,36 +0,0 @@
-/**
- * Server-side cross-project policy wiring shared by the hono and effect BFF
- * runtime adapters.
- *
- * The generated cross-project SDK force-enables `bff.crossProjectPolicy`
- * (see `crossProjectApiPlugin`), so producer servers MUST actually evaluate
- * it: this module resolves the policy once per adapter (deriving the
- * operation-contract map and the producer operation version from the app's
- * package.json major) and exposes a request check both adapters call before
- * dispatching API handlers.
- *
- * The envelope/operation-context headers are client-asserted; see the threat
- * model in `@modern-js/bff-core` `security/crossProjectPolicy.ts`. Operators
- * Production namespace allowlists require `verifyProducerIdentity` to bind
- * the namespace to a verified channel; without it, only non-production keeps
- * the advisory client-asserted allowlist path.
- */
-import { type OperationContractSource, type ResolvedCrossProjectPolicy } from '@modern-js/bff-core';
-import type { ServerPluginAPI } from '@modern-js/server-core';
-export type { ResolvedCrossProjectPolicy };
-/**
- * Resolves the effective cross-project policy for a BFF runtime adapter.
- * Returns `undefined` when no policy is configured and the server is not a
- * generated cross-project producer (no middleware should be installed).
- */
-export declare const resolveAdapterCrossProjectPolicy: (api: ServerPluginAPI, handlers: OperationContractSource[]) => ResolvedCrossProjectPolicy | undefined;
-/**
- * Evaluates the policy against a header record and returns the denial
- * Response every adapter must send, or `null` when the request passes.
- */
-export declare const checkCrossProjectPolicyResponse: (headers: Record<string, unknown>, policy: ResolvedCrossProjectPolicy | undefined) => Response | null;
-/**
- * Adapts the policy check to a WHATWG `Request` (effect lane seam): returns
- * the denial Response or `null`.
- */
-export declare const checkCrossProjectPolicyForRequest: (request: Request, policy: ResolvedCrossProjectPolicy | undefined) => Response | null;

package/dist/types/utils/effect-client-generator/generator.d.ts

@@ -1,10 +0,0 @@
-import type { EffectClientCodegenOptions, GeneratedEffectClientArtifacts } from './types';
-/**
- * Generates the Effect client module plus its type declaration. The module
- * body is a thin manifest + one call into
- * `@modern-js/plugin-bff/effect-client-runtime`; the declaration preserves
- * the group/endpoint structure of the HttpApi instead of erasing it to
- * `Record<string, ...>`.
- */
-export declare function generateEffectClient(options: EffectClientCodegenOptions): Promise<GeneratedEffectClientArtifacts | null>;
-export declare function generateEffectClientCode(options: EffectClientCodegenOptions): Promise<string | null>;

package/dist/types/utils/effect-client-generator/index.d.ts

@@ -1,4 +0,0 @@
-export { generateEffectClient, generateEffectClientCode } from './generator';
-export { resolveEffectEntryFile } from './paths';
-export { renderEffectClientDeclaration } from './rendering';
-export type { EffectClientCodegenOptions, GeneratedEffectClientArtifacts, } from './types';

package/dist/types/utils/effect-client-generator/paths.d.ts

@@ -1,5 +0,0 @@
-export declare function resolveEffectEntryFile(options: {
-    appDir: string;
-    apiDir: string;
-    effectEntry?: string;
-}): string | false | undefined;

package/dist/types/utils/effect-client-generator/rendering.d.ts

@@ -1,4 +0,0 @@
-import { type EffectEndpointMeta } from '../../runtime/effect/endpoint-contracts';
-import type { EffectClientCodegenOptions } from './types';
-export declare function renderEffectClientCode(endpoints: EffectEndpointMeta[], options: EffectClientCodegenOptions): string;
-export declare function renderEffectClientDeclaration(endpoints?: EffectEndpointMeta[]): string;

package/dist/types/utils/effect-client-generator/runtime.d.ts

@@ -1,12 +0,0 @@
-import { type HttpApiLike, type HttpApiReflect } from '../../runtime/effect/endpoint-contracts';
-type HttpApiRuntime = {
-    isHttpApi: (value: unknown) => boolean;
-    reflect: HttpApiReflect;
-};
-export declare function getHttpApiRuntime(): Promise<HttpApiRuntime>;
-export declare function loadEffectApi(options: {
-    appDir: string;
-    resourcePath: string;
-    onDependency?: (dependency: string) => void;
-}): Promise<HttpApiLike | null>;
-export {};

package/dist/types/utils/effect-client-generator/types.d.ts

@@ -1,27 +0,0 @@
-import type { HttpMethodDecider } from '@modern-js/types';
-import type { EffectEndpointMeta } from '../../runtime/effect/endpoint-contracts';
-export type EffectClientCodegenOptions = {
-    appDir: string;
-    apiDir: string;
-    resourcePath: string;
-    prefix: string;
-    port: number;
-    target?: string;
-    requestCreator?: string;
-    httpMethodDecider?: HttpMethodDecider;
-    onDependency?: (dependency: string) => void;
-    dataPlatformBatch?: {
-        enabled?: boolean;
-        endpoint?: string;
-        flushIntervalMs?: number;
-        maxBatchSize?: number;
-        maxBatchBytes?: number;
-        requestTimeoutMs?: number;
-        allowedMethods?: string[];
-    };
-};
-export type GeneratedEffectClientArtifacts = {
-    code: string;
-    declaration: string;
-    endpoints: EffectEndpointMeta[];
-};

package/dist/types/utils/effectClientGenerator.d.ts

@@ -1,2 +0,0 @@
-export type { EffectClientCodegenOptions, GeneratedEffectClientArtifacts, } from './effect-client-generator';
-export { generateEffectClient, generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile, } from './effect-client-generator';

package/dist/types/utils/effectSourceLoader.d.ts

@@ -1,25 +0,0 @@
-export type EffectSourceLoaderOptions = {
-    resourcePath: string;
-    appDir?: string;
-    onDependency?: (dependency: string) => void;
-};
-export declare function bundleEffectEntryForNode(options: {
-    appDir: string;
-    entryPath: string;
-    format: 'cjs' | 'esm';
-}): Promise<void>;
-/**
- * Loads the relocatable artifact emitted by the production BFF build.
- *
- * Production entries have already been compiled and bundled by
- * `bundleEffectEntryForNode`. Loading that artifact through the development
- * source-graph bundler a second time changes its module format and can strip
- * CommonJS runtime globals from bundled dependencies. Keep the built module's
- * native Node boundary intact instead.
- */
-export declare function loadEffectBuiltModule(resourcePath: string): Promise<unknown>;
-/**
- * Loads an Effect source entry as native ESM while keeping its complete local
- * source graph observable by the framework watcher.
- */
-export declare function loadEffectSourceModule(options: EffectSourceLoaderOptions): Promise<unknown>;

package/dist/types/utils/headers.d.ts

@@ -1 +0,0 @@
-export declare function toHeaderRecord(headers: Headers): Record<string, string>;