@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

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

@@ -0,0 +1,14 @@
+import type { HttpApi } from 'effect/unstable/httpapi';
+import type { Rpc } from 'effect/unstable/rpc';
+import type { EffectBffOpenApiConfig, EffectDataPlatformValidationOptions, EffectRequestValidator, EffectRpcBffDefinition, EffectRuntimeLayer } from './types';
+export declare function createHttpApiHandler<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TRpcs extends Rpc.Any = Rpc.Any>(options: {
+    api: TApi;
+    layer: EffectRuntimeLayer;
+    openapi?: EffectBffOpenApiConfig;
+    rpc?: EffectRpcBffDefinition<TRpcs>;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+    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

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

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,148 @@
+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.AnyWithProps = HttpApi.AnyWithProps> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Any>, never, never> : never;
+export type EffectApiPromiseClientFromApi<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
+export type EffectBffDefinition<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
+    api: TApi;
+    layer: TLayer;
+    rpc?: EffectRpcBffDefinition<TRpcs>;
+    dataPlatform?: EffectDataPlatformValidationOptions;
+};
+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 EffectBffHandlerFactory<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
+    openapi?: EffectBffOpenApiConfig;
+    rpc?: Partial<EffectRpcBffHandlerOptions>;
+    dataPlatform?: Partial<EffectDataPlatformValidationOptions>;
+    validateRequest?: EffectRequestValidator;
+}) => ReturnType<typeof createHttpApiHandler>;
+export type EffectBffRuntime<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, 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,10 +1,3 @@
-import type { FileSystem, Path } from 'effect';
-import * as Context from 'effect/Context';
-import type * as EffectType from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import { Etag, HttpPlatform, HttpRouter } from 'effect/unstable/http';
-import { type HttpApi, type HttpApiClient, type HttpApiGroup } from 'effect/unstable/httpapi';
-import { type Rpc, type RpcGroup } from 'effect/unstable/rpc';
 export * as Config from 'effect/Config';
 export * as Effect from 'effect/Effect';
 export * as Layer from 'effect/Layer';
@@ -16,169 +9,6 @@ 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 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 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.AnyWithProps = HttpApi.AnyWithProps> = TApi extends HttpApi.HttpApi<infer _ApiId, infer Groups> ? HttpApiClient.Client<Extract<Groups, HttpApiGroup.Any>, never, never> : never;
-export type EffectApiPromiseClientFromApi<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps> = EffectApiPromiseClient<EffectApiClientFromApi<TApi>>;
-export type EffectBffDefinition<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any> = {
-    api: TApi;
-    layer: TLayer;
-    rpc?: EffectRpcBffDefinition<TRpcs>;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-};
-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 EffectBffHandlerFactory<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
-    openapi?: EffectBffOpenApiConfig;
-    rpc?: Partial<EffectRpcBffHandlerOptions>;
-    dataPlatform?: Partial<EffectDataPlatformValidationOptions>;
-    validateRequest?: EffectRequestValidator;
-}) => ReturnType<typeof createHttpApiHandler>;
-export type EffectBffRuntime<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, 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>>;
-declare function createRpcApiHandler<TRpcs extends Rpc.Any = Rpc.Any>(options: EffectRpcBffDefinition<TRpcs>): {
-    readonly handler: (request: globalThis.Request, context?: Context.Context<never> | undefined) => Promise<Response>;
-    readonly dispose: () => Promise<void>;
-};
-export declare function defineEffectBff<TApi extends HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer, TRpcs extends Rpc.Any = Rpc.Any>(definition: {
-    api: TApi;
-    layer: TLayer;
-    rpc?: EffectRpcBffDefinition<TRpcs>;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-}): {
-    api: TApi;
-    layer: TLayer;
-    rpc?: EffectRpcBffDefinition<TRpcs>;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-} & 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>;
-};
-export declare function createHttpApiHandler<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TRpcs extends Rpc.Any = Rpc.Any>(options: {
-    api: TApi;
-    layer: EffectRuntimeLayer;
-    openapi?: EffectBffOpenApiConfig;
-    rpc?: EffectRpcBffDefinition<TRpcs>;
-    dataPlatform?: EffectDataPlatformValidationOptions;
-    validateRequest?: EffectRequestValidator;
-}): {
-    handler: (request: Request, context?: Parameters<(request: globalThis.Request, context: Context.Context<unknown>) => Promise<Response>>[1]) => Promise<Response>;
-    dispose: () => Promise<void>;
-};
+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/rpcSerialization.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,3 @@
+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

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

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

@@ -1,71 +1,5 @@
-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;
-};
+import type { EffectRequestRuntime, GeneratedEffectClientConfig, GeneratedEffectClientModule, GeneratedEffectEndpoint } from './types';
+export type { EffectClient, EffectClientGroup, EffectClientOperation, EffectOperationDescriptor, EffectOperationManifest, EffectRequestContext, EffectRequestContextInput, EffectRequestRuntime, GeneratedEffectBatchConfig, GeneratedEffectClientConfig, GeneratedEffectClientModule, GeneratedEffectEndpoint, } from './types';
 export declare const createGeneratedEffectClient: (manifest: {
     endpoints: GeneratedEffectEndpoint[];
 }, config: GeneratedEffectClientConfig, requestRuntime: EffectRequestRuntime) => GeneratedEffectClientModule;

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

@@ -0,0 +1,68 @@
+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/utils/client-generator/files.d.ts

@@ -0,0 +1,28 @@
+export interface FileDetails {
+    resourcePath: string;
+    source: string;
+    targetDir: string;
+    name: string;
+    absTargetDir: string;
+    relativeTargetDistDir: string;
+    exportKey: string;
+}
+export declare const API_DIR = "api";
+export declare const PLUGIN_DIR = "plugin";
+export declare const RUNTIME_DIR = "runtime";
+export declare const CLIENT_DIR = "client";
+export declare const EXPORT_PREFIX = "./api/";
+export declare const TYPE_PREFIX = "api/";
+export declare const GENERATED_RUNTIME_DIRS: string[];
+export declare const toPosixPath: (p: string) => string;
+export declare const posixJoin: (...args: string[]) => string;
+export declare function createFileDetails(options: {
+    appDirectory: string;
+    baseDirectory: string;
+    resourcePath: string;
+    source: string;
+    relativeDistPath: string;
+}): FileDetails;
+export declare function readDirectoryFiles(appDirectory: string, directory: string, relativeDistPath: string): Promise<FileDetails[]>;
+export declare function writeTargetFile(absTargetDir: string, content: string): Promise<void>;
+export declare function copyFiles(from: string, to: string): Promise<void>;

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

@@ -0,0 +1,26 @@
+import type { HttpMethodDecider } from '@modern-js/types';
+export type APILoaderOptions = {
+    prefix: string;
+    appDir: string;
+    apiDir: string;
+    lambdaDir: string;
+    existLambda: boolean;
+    port?: number;
+    requestCreator?: string;
+    httpMethodDecider?: HttpMethodDecider;
+    relativeDistPath: string;
+    relativeApiPath: string;
+    bffRuntimeFramework?: 'hono' | 'effect';
+    effectEntry?: string;
+    effectDataPlatformBatch?: {
+        enabled?: boolean;
+        endpoint?: string;
+        flushIntervalMs?: number;
+        maxBatchSize?: number;
+        maxBatchBytes?: number;
+        requestTimeoutMs?: number;
+        allowedMethods?: string[];
+    };
+};
+export declare function clientGenerator(draftOptions: APILoaderOptions): Promise<void>;
+export default clientGenerator;

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

@@ -0,0 +1,7 @@
+export type { FileDetails } from './files';
+export { copyFiles, createFileDetails, readDirectoryFiles, writeTargetFile, } from './files';
+export type { APILoaderOptions } from './generate';
+export { clientGenerator, default } from './generate';
+export type { PackageJsonLike } from './package-json';
+export { getClientPackageName, getPackageName, mergePackageJson, } from './package-json';
+export { setPackage, writeClientModuleBoundary } from './write-package';

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

@@ -0,0 +1,16 @@
+export type PackageJsonLike = {
+    files?: string[];
+    typesVersions?: Record<string, Record<string, string[]>>;
+    exports?: Record<string, {
+        import?: string;
+        require?: string;
+        types?: string;
+    }>;
+};
+export declare function getPackageName(appDirectory: string): string | undefined;
+export declare function mergePackageJson(packageJson: PackageJsonLike, files: string[], typesVersion: Record<string, Record<string, string[]>>, exports: Record<string, {
+    import?: string;
+    require?: string;
+    types?: string;
+}>, relativeDistPath: string): void;
+export declare function getClientPackageName(appDirectory: string): string;

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

@@ -0,0 +1,6 @@
+export declare function writeClientModuleBoundary(appDirectory: string, relativeDistPath: string): Promise<void>;
+export declare function setPackage(files: {
+    exportKey: string;
+    targetDir: string;
+    relativeTargetDistDir: string;
+}[], appDirectory: string, relativeDistPath: string): Promise<void>;