@bleedingdev/modern-js-plugin-bff 3.2.0-ultramodern.0

package/dist/esm-node/utils/runtimeGenerator.mjs

@@ -0,0 +1,91 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { fs } from "@modern-js/utils";
+import path from "path";
+const getPackageName = (appDirectory)=>{
+    try {
+        const packageJsonPath = path.resolve(appDirectory, './package.json');
+        const packageJson = require(packageJsonPath);
+        return packageJson.name;
+    } catch (error) {
+        return;
+    }
+};
+async function runtimeGenerator({ runtime, appDirectory, relativeDistPath, packageName }) {
+    const pluginDir = path.resolve(appDirectory, `./${relativeDistPath}`, 'runtime');
+    const requestId = packageName || getPackageName(appDirectory) || process.env.npm_package_name || 'default';
+    const runtimeImportPath = JSON.stringify(runtime);
+    const requestIdValue = JSON.stringify(requestId);
+    const source = `const { configure: _configure } = require(${runtimeImportPath});
+    const defaultSecureOptions = {
+      requestId: ${requestIdValue},
+      requireEnvelope: true,
+      identityBinding: {
+        enabled: true,
+        strict: true,
+      },
+      operationContract: {
+        enabled: true,
+        strict: true,
+        requireSchemaHash: true,
+        requireOperationVersion: true,
+      },
+    };
+    const initProducerClient = (options) => {
+      return _configure({
+        ...defaultSecureOptions,
+        ...options,
+        identityBinding: {
+          ...defaultSecureOptions.identityBinding,
+          ...(options && options.identityBinding ? options.identityBinding : {}),
+        },
+        operationContract: {
+          ...defaultSecureOptions.operationContract,
+          ...(options && options.operationContract ? options.operationContract : {}),
+        },
+      });
+    }
+    const configure = initProducerClient;
+    Object.defineProperty(exports, '__esModule', { value: true });
+    exports.initProducerClient = initProducerClient;
+    exports.configure = configure;
+  `;
+    const pluginPath = path.join(pluginDir, 'index.js');
+    await fs.ensureFile(pluginPath);
+    await fs.writeFile(pluginPath, source);
+    const tsSource = `type ProducerRuntimeModule = typeof import(${runtimeImportPath});
+  type ProducerClientOptions = ProducerRuntimeModule extends {
+    configure: (options: infer TOptions) => unknown;
+  }
+    ? TOptions
+    : {
+        request?: typeof fetch;
+        interceptor?: (request: typeof fetch) => typeof fetch;
+        allowedHeaders?: string[];
+        requireEnvelope?: boolean;
+        allowCrossOriginEnvelope?: boolean;
+        identityBinding?: {
+          enabled?: boolean;
+          strict?: boolean;
+          protectedHeaders?: string[];
+        };
+        operationContract?: {
+          enabled?: boolean;
+          strict?: boolean;
+          requireSchemaHash?: boolean;
+          requireOperationVersion?: boolean;
+        };
+        setDomain?: (ops?: {
+          target: 'server' | 'browser';
+          requestId?: string;
+        }) => string;
+        requestId?: string;
+      };
+  export declare const initProducerClient: (options: ProducerClientOptions) => void;
+  export declare const configure: typeof initProducerClient;`;
+    const pluginTypePath = path.join(pluginDir, 'index.d.ts');
+    await fs.ensureFile(pluginTypePath);
+    await fs.writeFile(pluginTypePath, tsSource);
+}
+const utils_runtimeGenerator = runtimeGenerator;
+export default utils_runtimeGenerator;

package/dist/types/cli.d.ts

@@ -0,0 +1,3 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+export declare const bffPlugin: () => CliPlugin<AppTools>;
+export default bffPlugin;

package/dist/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const API_APP_NAME = "_app";
+export declare const BUILD_FILES: string[];

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './constants';

package/dist/types/loader.d.ts

@@ -0,0 +1,27 @@
+import type { HttpMethodDecider } from '@modern-js/types';
+import type { Rspack } from '@rsbuild/core';
+export type APILoaderOptions = {
+    prefix: string;
+    appDir: string;
+    apiDir: string;
+    lambdaDir: string;
+    existLambda: boolean;
+    port: number;
+    fetcher?: string;
+    requestCreator?: string;
+    target: string;
+    httpMethodDecider?: HttpMethodDecider;
+    bffRuntimeFramework?: 'hono' | 'effect';
+    effectEntry?: string;
+    effectDataPlatformBatch?: {
+        enabled?: boolean;
+        endpoint?: string;
+        flushIntervalMs?: number;
+        maxBatchSize?: number;
+        maxBatchBytes?: number;
+        requestTimeoutMs?: number;
+        allowedMethods?: string[];
+    };
+};
+declare function loader(this: Rspack.LoaderContext<APILoaderOptions>, source: string): Promise<void>;
+export default loader;

package/dist/types/runtime/create-request/index.d.ts

@@ -0,0 +1,2 @@
+import { configure, createRequest, createRequestContextHeaders, createRequestContextSnapshot, createUploader } from '@modern-js/create-request';
+export { configure, createRequest, createRequestContextHeaders, createRequestContextSnapshot, createUploader, };

package/dist/types/runtime/data-platform/index.d.ts

@@ -0,0 +1,187 @@
+export type DataRequestMode = 'cache-first' | 'stale-while-revalidate' | 'network-only';
+export type DataMutationMode = 'optimistic' | 'pessimistic' | 'fire-and-forget';
+export type SelectionPlan = {
+    [field: string]: true | SelectionPlan;
+};
+export interface OperationDescriptor {
+    appNamespace: string;
+    apiId: string;
+    group: string;
+    endpoint: string;
+    schemaHash?: string;
+    version?: number;
+}
+export interface CacheScope {
+    appNamespace: string;
+    origin: string;
+    tenantId?: string;
+    userId?: string;
+    sessionId?: string;
+}
+export interface TraceContext {
+    traceId: string;
+    spanId: string;
+    sampled: boolean;
+    parentSpanId?: string;
+}
+export interface RequestEnvelope<Input = unknown> {
+    protocolVersion: 1;
+    operationId: string;
+    appNamespace: string;
+    origin: string;
+    requestMode: DataRequestMode;
+    mutationMode?: DataMutationMode;
+    scopeKey: string;
+    input: Input;
+    inputHash: string;
+    selectionPlan?: SelectionPlan;
+    selectionHash?: string;
+    traceparent?: string;
+    timestamp: number;
+}
+export interface HydrationEnvelope<Payload = unknown> {
+    protocolVersion: 1;
+    runtimeVersion: string;
+    appNamespace: string;
+    origin: string;
+    createdAt: number;
+    payload: Payload;
+    checksum: string;
+}
+export interface InvalidationEvent {
+    sourceNamespace: string;
+    sourceOperationId: string;
+    scopeKey: string;
+    targetNamespaces?: string[];
+    targetOperationIds?: string[];
+}
+export interface InvalidationSubscriber {
+    namespace: string;
+    operationIds?: string[];
+    scopeKey?: string;
+    acceptCrossNamespace?: boolean;
+}
+export interface DataBatchRequestItem {
+    id: string;
+    path: string;
+    method: string;
+    headers?: Record<string, string>;
+    body?: string;
+}
+export interface DataBatchRequestPayload {
+    protocolVersion: 1;
+    batchId: string;
+    sentAt: number;
+    items: DataBatchRequestItem[];
+}
+export interface DataBatchResponseItem {
+    id: string;
+    status: number;
+    headers?: Record<string, string>;
+    body?: string;
+}
+export interface DataBatchResponsePayload {
+    protocolVersion: 1;
+    batchId: string;
+    receivedAt: number;
+    items: DataBatchResponseItem[];
+}
+export interface DataBatchTransportEvent {
+    type: 'enqueue' | 'flush' | 'fallback' | 'disable';
+    endpoint: string;
+    batchId?: string;
+    size?: number;
+    reason?: string;
+}
+export interface DataBatchTransportOptions {
+    endpoint?: string;
+    fetch?: (input: DataTransportRequestInfo, init?: RequestInit) => Promise<Response>;
+    flushIntervalMs?: number;
+    maxBatchSize?: number;
+    maxBatchBytes?: number;
+    requestTimeoutMs?: number;
+    allowedMethods?: string[];
+    onEvent?: (event: DataBatchTransportEvent) => void;
+}
+export interface SelectionPlanValidationOptions {
+    maxDepth?: number;
+    maxFields?: number;
+    allowedLeafPaths?: ReadonlyArray<string>;
+}
+export interface SelectionPlanValidationResult {
+    ok: boolean;
+    errors: string[];
+    stats: {
+        maxDepth: number;
+        fieldCount: number;
+    };
+}
+export interface RequestEnvelopeValidationOptions {
+    expectedProtocolVersion?: number;
+    expectedNamespace?: string;
+    expectedOrigin?: string;
+    requireTraceContext?: boolean;
+}
+export interface HydrationEnvelopeValidationOptions {
+    expectedProtocolVersion?: number;
+    expectedNamespace?: string;
+    expectedOrigin?: string;
+    expectedRuntimeVersion?: string;
+}
+export declare const DEFAULT_DATA_ENVELOPE_HEADER = "x-modernjs-data-envelope";
+export declare const DEFAULT_DATA_BATCH_ENDPOINT = "/_data/batch";
+export declare const DEFAULT_DATA_BATCH_HEADER = "x-modernjs-data-batch";
+type DataTransportRequestInfo = string | URL | Request;
+export declare function stableStringify(value: unknown): string;
+export declare function encodeRequestEnvelopeHeader(envelope: RequestEnvelope): string;
+export declare function decodeRequestEnvelopeHeader(value: string): RequestEnvelope | null;
+export declare function normalizeOrigin(origin: string): string;
+export declare function createOperationId(input: OperationDescriptor): string;
+export declare function buildScopeKey(scope: CacheScope): string;
+export declare function buildQueryKey(input: {
+    operationId: string;
+    scopeKey: string;
+    requestMode?: DataRequestMode;
+    requestInput?: unknown;
+    selectionPlan?: SelectionPlan;
+}): string;
+export declare function parseTraceparentHeader(header: string): TraceContext | null;
+export declare function formatTraceparentHeader(trace: TraceContext): string;
+export declare function deriveChildTraceContext(parent: TraceContext, childSpanId: string): TraceContext;
+export declare function validateSelectionPlan(plan: SelectionPlan, options?: SelectionPlanValidationOptions): SelectionPlanValidationResult;
+export declare function createRequestEnvelope<Input>(input: {
+    operation: OperationDescriptor;
+    scope: CacheScope;
+    requestInput: Input;
+    selectionPlan?: SelectionPlan;
+    requestMode?: DataRequestMode;
+    mutationMode?: DataMutationMode;
+    traceContext?: TraceContext;
+    requireTraceContext?: boolean;
+    timestamp?: number;
+    protocolVersion?: 1;
+}): RequestEnvelope<Input>;
+export declare function validateRequestEnvelope(envelope: RequestEnvelope, options?: RequestEnvelopeValidationOptions): {
+    ok: boolean;
+    errors: string[];
+};
+export declare function createHydrationEnvelope<Payload>(input: {
+    runtimeVersion: string;
+    scope: Pick<CacheScope, 'appNamespace' | 'origin'>;
+    payload: Payload;
+    createdAt?: number;
+    protocolVersion?: 1;
+}): HydrationEnvelope<Payload>;
+export declare function validateHydrationEnvelope(envelope: HydrationEnvelope, options?: HydrationEnvelopeValidationOptions): {
+    ok: boolean;
+    errors: string[];
+};
+export declare function createInvalidationEvent(input: {
+    sourceOperation: OperationDescriptor;
+    sourceScope: CacheScope;
+    targetNamespaces?: string[];
+    targetOperations?: OperationDescriptor[];
+}): InvalidationEvent;
+export declare function shouldApplyInvalidation(event: InvalidationEvent, subscriber: InvalidationSubscriber): boolean;
+export declare function createDataBatchTransport(options?: DataBatchTransportOptions): (input: DataTransportRequestInfo, init?: RequestInit) => Promise<any>;
+export {};

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

@@ -0,0 +1,22 @@
+import type { ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
+interface MiddlewareOptions {
+    prefix: string;
+    enableHandleWeb?: boolean;
+}
+export declare class EffectAdapter {
+    api: ServerPluginAPI;
+    isEffect: boolean;
+    effectMiddleware: ServerMiddleware | null;
+    private handler;
+    private dispose;
+    constructor(api: ServerPluginAPI);
+    registerMiddleware: (options: MiddlewareOptions) => Promise<void>;
+    onApiHandlersUpdated: () => Promise<void>;
+    private resolveEntryFile;
+    private loadEffectHandlerFromModule;
+    private reloadHandler;
+    private disposeCurrentHandler;
+    private handleRuntimeError;
+    private ensureJsonContext;
+}
+export {};

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

@@ -0,0 +1,8 @@
+export type EffectContext = {
+    request: Request;
+    env: Record<string, unknown>;
+    path: string;
+    method: string;
+};
+export declare const runWithEffectContext: <T>(context: EffectContext, cb: () => T) => T;
+export declare const useEffectContext: () => EffectContext;

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

@@ -0,0 +1,171 @@
+import type * as EffectType from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { type HttpApi, type HttpApiClient, type HttpApiGroup } from 'effect/unstable/httpapi';
+import { type Rpc, type RpcGroup } from 'effect/unstable/rpc';
+export * as OpenTelemetry from '@effect/opentelemetry';
+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 { type EffectContext, useEffectContext } from './context';
+export type EffectRuntimeLayer = Layer.Layer<any, unknown, 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>, unknown, 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;
+};
+export type EffectBffHandlerFactory<TApi extends HttpApi.AnyWithProps = HttpApi.AnyWithProps, TLayer extends EffectRuntimeLayer = EffectRuntimeLayer> = (options?: {
+    openapi?: EffectBffOpenApiConfig;
+    rpc?: Partial<EffectRpcBffHandlerOptions>;
+    dataPlatform?: Partial<EffectDataPlatformValidationOptions>;
+}) => 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?: import("effect/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;
+}): {
+    handler: (request: Request, context?: Parameters<(request: globalThis.Request, context?: import("effect/Context").Context<never> | undefined) => Promise<Response>>[1]) => Promise<Response>;
+    dispose: () => Promise<void>;
+};

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

@@ -0,0 +1,47 @@
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from 'effect/unstable/httpapi';
+import { Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization } from 'effect/unstable/rpc';
+export * as Effect from 'effect/Effect';
+export * as Layer from 'effect/Layer';
+export * as Schema from 'effect/Schema';
+export { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, Rpc, RpcClient, RpcGroup, RpcSchema, RpcSerialization, };
+export type EffectHttpApiClientOptions = {
+    baseUrl?: URL | string;
+};
+type Nullish = null | undefined;
+type NonNullish<T> = Exclude<T, Nullish>;
+type PreserveNullish<T, Next> = Extract<T, Nullish> extends never ? Next : Next | Extract<T, Nullish>;
+type EffectViewObjectSelection<T> = NonNullish<T> extends Record<string, unknown> ? EffectViewSelection<NonNullish<T>> : never;
+type EffectViewSelectionValue<T> = NonNullish<T> extends readonly (infer Item)[] ? true | EffectViewObjectSelection<Item> : NonNullish<T> extends Record<string, unknown> ? true | EffectViewSelection<NonNullish<T>> : true;
+type EffectMaskedValue<T, Selection> = Selection extends true ? T : NonNullish<T> extends readonly (infer Item)[] ? PreserveNullish<T, Array<EffectMaskedValue<Item, Selection>>> : NonNullish<T> extends Record<string, unknown> ? PreserveNullish<T, EffectViewData<NonNullish<T>, Selection>> : T;
+export type EffectViewSelection<T> = {
+    [K in keyof T]?: EffectViewSelectionValue<T[K]>;
+};
+export type EffectViewData<T, Selection> = Selection extends true ? T : Selection extends Record<string, unknown> ? {
+    [K in keyof Selection & keyof T]: EffectMaskedValue<T[K], Selection[K]>;
+} : T;
+export type EffectRpcSerialization = 'json' | 'ndjson' | 'jsonRpc' | 'ndJsonRpc' | 'msgPack';
+type EffectRpcMiddlewareLayerOption<Rpcs extends Rpc.Any> = [
+    Rpc.MiddlewareClient<Rpcs>
+] extends [never] ? {
+    middlewareLayer?: Layer.Layer<Rpc.MiddlewareClient<Rpcs>, never, never>;
+} : {
+    middlewareLayer: Layer.Layer<Rpc.MiddlewareClient<Rpcs>, unknown, never>;
+};
+export type EffectRpcClientOptions<Rpcs extends Rpc.Any, Flatten extends boolean = false> = EffectRpcMiddlewareLayerOption<Rpcs> & {
+    url: string;
+    flatten?: Flatten;
+    serialization?: EffectRpcSerialization;
+};
+export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean = false> = (Flatten extends true ? RpcClient.RpcClient.Flat<Rpcs, unknown> : RpcClient.RpcClient<Rpcs, unknown>) & {
+    dispose: () => Promise<void>;
+};
+export declare function view<T>(): <const Selection extends EffectViewSelection<T>>(selection: Selection) => Selection;
+export declare function mask<T, const Selection extends EffectViewSelection<T>>(value: T, selection: Selection): EffectViewData<T, Selection>;
+export declare function runEffectView<T, const Selection extends EffectViewSelection<T>>(request: PromiseLike<T>, selection: Selection): Promise<EffectViewData<T, Selection>>;
+export declare function makeEffectHttpApiClient<ApiId extends string, Groups extends HttpApiGroup.Any>(api: HttpApi.HttpApi<ApiId, Groups>, options?: EffectHttpApiClientOptions): Effect.Effect<import("effect/Types").Simplify<{ readonly [Group in Extract<Groups, {
+    readonly topLevel: false;
+}> as HttpApiGroup.Name<Group>]: HttpApiClient.Client.Group<Group, Group["identifier"], never, never>; } & { readonly [Method in HttpApiClient.Client.TopLevelMethods<Groups, never, never> as Method[0]]: Method[1]; }>, never, Exclude<import("effect/unstable/httpapi/HttpApiMiddleware").MiddlewareClient<HttpApiEndpoint.Middleware<HttpApiGroup.Endpoints<Groups>>>, import("effect/unstable/http/HttpClient").HttpClient>>;
+export declare function makeEffectRpcClient<Rpcs extends Rpc.Any, const Flatten extends boolean = false>(group: RpcGroup.RpcGroup<Rpcs>, options: EffectRpcClientOptions<Rpcs, Flatten>): Effect.Effect<EffectRpcClientHandle<Rpcs, Flatten>, Error, never>;
+export declare const runEffectRequest: <A, E>(effect: Effect.Effect<A, E>, options?: Effect.RunOptions | undefined) => Promise<A>;

package/dist/types/runtime/hono/adapter.d.ts

@@ -0,0 +1,19 @@
+import type { MiddlewareHandler, ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
+import { Hono } from '@modern-js/server-core';
+interface MiddlewareOptions {
+    prefix: string;
+    enableHandleWeb?: boolean;
+}
+export declare class HonoAdapter {
+    apiMiddleware: ServerMiddleware[];
+    apiServer: Hono | null;
+    api: ServerPluginAPI;
+    isHono: boolean;
+    constructor(api: ServerPluginAPI);
+    setHandlers: () => Promise<void>;
+    registerApiRoutes: () => Promise<void>;
+    registerMiddleware: (options: MiddlewareOptions) => Promise<void>;
+    onApiHandlersUpdated: () => Promise<void>;
+    wrapInArray(handler: MiddlewareHandler[] | MiddlewareHandler): MiddlewareHandler[];
+}
+export {};

package/dist/types/runtime/hono/index.d.ts

@@ -0,0 +1,2 @@
+export * from '@modern-js/bff-core';
+export * from './operators';

package/dist/types/runtime/hono/operators.d.ts

@@ -0,0 +1,10 @@
+import type { Operator } from '@modern-js/bff-core';
+import { type Context, type Next } from '@modern-js/server-core';
+export type EndFunction = ((func: (res: Response) => void) => void) & ((data: unknown) => void);
+type MaybeAsync<T> = T | Promise<T>;
+type PipeFunction<T> = (value: T, end: EndFunction) => MaybeAsync<void> | MaybeAsync<T>;
+export declare const Pipe: <T>(func: PipeFunction<T>) => Operator<T>;
+export type Pipe = typeof Pipe;
+export declare const Middleware: (middleware: (c: Context, next: Next) => void) => Operator<void>;
+export type Middleware = typeof Middleware;
+export {};

package/dist/types/server.d.ts

@@ -0,0 +1,3 @@
+import type { ServerPlugin } from '@modern-js/server-core';
+declare const _default: () => ServerPlugin;
+export default _default;

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

@@ -0,0 +1,37 @@
+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[];
+    };
+};
+interface FileDetails {
+    resourcePath: string;
+    source: string;
+    targetDir: string;
+    name: string;
+    absTargetDir: string;
+    relativeTargetDistDir: string;
+    exportKey: string;
+}
+export declare function readDirectoryFiles(appDirectory: string, directory: string, relativeDistPath: string): Promise<FileDetails[]>;
+export declare function copyFiles(from: string, to: string): Promise<void>;
+declare function clientGenerator(draftOptions: APILoaderOptions): Promise<void>;
+export default clientGenerator;

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

@@ -0,0 +1,10 @@
+import type { APIHandlerInfo } from '@modern-js/bff-core';
+import type { Context } from '@modern-js/server-core';
+type Handler = APIHandlerInfo['handler'];
+declare const createHonoRoutes: (handlerInfos?: APIHandlerInfo[]) => {
+    method: any;
+    path: string;
+    handler: any[] | ((c: Context) => Promise<void | Response>);
+}[];
+export declare const createHonoHandler: (handler: Handler) => (c: Context) => Promise<void | Response>;
+export default createHonoRoutes;