@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.10 → 3.5.0-ultramodern.100

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

@@ -1,4 +1,7 @@
 export * as OpenTelemetry from '@effect/opentelemetry';
+export * from './backend-federation';
+export { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, type BackendFederatedEffectApiModule, type BackendFederationEntryExports, type BackendFederationLoadEntryPluginOptions, type BackendFederationRemote, type BackendFederationRuntimeOptions, createBackendFederationLoadEntryPlugin, createBackendFederationRuntime, loadBackendFederatedEffectApi, } from './backend-federation';
+export { type BackendFederationManifest, BackendFederationManifestAdapterError, type BackendFederationManifestAdapterErrorCode, type BackendFederationManifestAdapterFallback, type BackendFederationManifestAdapterOptions, type BackendFederationManifestFetchResponse, type BackendFederationVersionBoundaryExpectation, loadBackendFederatedEffectApiFromManifest, loadBackendFederationManifest, resolveBackendFederationRemoteFromManifest, } from './backend-federation-manifest';
 export { type CreateEffectOperationContextOptions, createEffectOperationContext, type EffectContext, runWithEffectContext, useEffectContext, useOperationContext, } from './context';
 export { createEffectBffEdgeHandler, createEffectBffTestHandler, dispatchEffectBffRequest, } from './edge';
 export * from './handler';

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

@@ -17,11 +17,11 @@ export type EffectApiModule = {
     createHandler?: EffectBffHandlerFactory;
     default?: unknown;
 };
-export type LoadedEffectBffHandler = {
+type LoadedEffectBffHandler = {
     handler: EffectBffRequestHandler;
     dispose?: () => Promise<void>;
 };
-export type ResolveEffectBffModuleHandlerOptions = {
+type ResolveEffectBffModuleHandlerOptions = {
     openapi?: EffectBffOpenApiConfig;
     dataPlatform?: EffectDataPlatformValidationOptions;
     /**
@@ -33,3 +33,4 @@ export type ResolveEffectBffModuleHandlerOptions = {
     onWarning?: (message: string) => void;
 };
 export declare function resolveEffectBffModuleHandler(mod: EffectApiModule, options?: ResolveEffectBffModuleHandlerOptions): Promise<LoadedEffectBffHandler | null>;
+export {};

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/index.d.ts

@@ -53,6 +53,6 @@ export type EffectRpcClientHandle<Rpcs extends Rpc.Any, Flatten extends boolean
 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<HttpApiClient.Client<Groups>, never, HttpApiGroup.MiddlewareClient<Groups>>;
+export declare function makeEffectHttpApiClient<ApiId extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<ApiId, Groups>, options?: EffectHttpApiClientOptions): Effect.Effect<HttpApiClient.Client<Groups, never, never>, never, HttpApiGroup.MiddlewareClient<Groups>>;
 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>, EffectRpcClientError, never>;
 export declare const runEffectRequest: <A, E>(effect: Effect.Effect<A, E>, options?: Effect.RunOptions | undefined) => Promise<A>;

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/runtime/hono/adapter.d.ts

@@ -1,22 +1,28 @@
-import type { MiddlewareHandler, ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
-import { Hono } from '@modern-js/server-core';
+import type { ServerMiddleware, ServerPluginAPI } from '@modern-js/server-core';
 import { type ResolvedCrossProjectPolicy } from '../../utils/crossProjectServerPolicy';
 interface MiddlewareOptions {
-    prefix: string;
+    prefix?: string;
     enableHandleWeb?: boolean;
 }
 export declare class HonoAdapter {
     apiMiddleware: ServerMiddleware[];
-    apiServer: Hono | null;
     api: ServerPluginAPI;
     isHono: boolean;
     prefix: string;
     crossProjectPolicy: ResolvedCrossProjectPolicy | undefined;
     constructor(api: ServerPluginAPI);
     setHandlers: () => Promise<void>;
-    registerApiRoutes: () => Promise<void>;
-    registerMiddleware: (options: MiddlewareOptions) => Promise<void>;
-    onApiHandlersUpdated: () => Promise<void>;
-    wrapInArray(handler: MiddlewareHandler[] | MiddlewareHandler): MiddlewareHandler[];
+    /**
+     * Register the BFF API routes as ordinary server middlewares.
+     *
+     * Dev and prod now share this single path: the routes are pushed straight
+     * into the server's middleware list. In dev, hot updates are handled by the
+     * unified `@modern-js/server` runtime reload (which rebuilds the whole
+     * runtime — including this plugin — from scratch), so BFF no longer needs its
+     * own swappable Hono sub-app / dynamic dispatch middleware.
+     */
+    registerMiddleware: (options?: MiddlewareOptions) => Promise<void>;
+    private handleRouteError;
+    private withErrorBoundary;
 }
 export {};

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

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

@@ -1,37 +1,2 @@
-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;
+export * from './client-generator';
+export { default } from './client-generator';

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

@@ -11,8 +11,9 @@
  *
  * The envelope/operation-context headers are client-asserted; see the threat
  * model in `@modern-js/bff-core` `security/crossProjectPolicy.ts`. Operators
- * who need a real trust boundary must additionally configure
- * `verifyProducerIdentity` to bind the namespace to a verified channel.
+ * 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';

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

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+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,41 +1,2 @@
-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;
-    dataPlatformBatch?: {
-        enabled?: boolean;
-        endpoint?: string;
-        flushIntervalMs?: number;
-        maxBatchSize?: number;
-        maxBatchBytes?: number;
-        requestTimeoutMs?: number;
-        allowedMethods?: string[];
-    };
-};
-export type GeneratedEffectClientArtifacts = {
-    code: string;
-    declaration: string;
-    endpoints: EffectEndpointMeta[];
-};
-export declare function renderEffectClientDeclaration(endpoints?: EffectEndpointMeta[]): string;
-/**
- * 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>;
-export declare function resolveEffectEntryFile(options: {
-    appDir: string;
-    apiDir: string;
-    effectEntry?: string;
-}): string | false | undefined;
+export type { EffectClientCodegenOptions, GeneratedEffectClientArtifacts, } from './effect-client-generator';
+export { generateEffectClient, generateEffectClientCode, renderEffectClientDeclaration, resolveEffectEntryFile, } from './effect-client-generator';

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

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