@bleedingdev/modern-js-plugin-bff-build-extensions 0.0.0 → 3.9.0-ultramodern.10

package/dist/esm-node/cross-project.mjs

@@ -0,0 +1,45 @@
+import "node:module";
+import "@modern-js/server-runtime-extensions/server-config";
+import node_path from "node:path";
+import { createCrossProjectApiPlugin } from "@modern-js/plugin-bff/cross-project";
+function createCrossProjectBffPlugin(descriptor) {
+    return createCrossProjectApiPlugin({
+        ...descriptor.native,
+        modifyResolvedConfig: (resolvedConfig, { sdkDistDirectory, api })=>{
+            const config = api.getConfig();
+            const configuredRuntimeFramework = config?.bff?.runtimeFramework;
+            if (configuredRuntimeFramework && configuredRuntimeFramework !== descriptor.runtimeFramework) throw new Error(`[${descriptor.native.packageName}] Runtime framework mismatch for cross-project BFF. Detected "${configuredRuntimeFramework}", but producer SDK requires "${descriptor.runtimeFramework}".`);
+            const effectEntry = descriptor.relativeEffectEntry ? node_path.join(sdkDistDirectory, descriptor.relativeEffectEntry) : void 0;
+            api.updateAppContext({
+                ...effectEntry ? {
+                    apiDirectory: node_path.dirname(effectEntry)
+                } : {},
+                bffRuntimeFramework: descriptor.runtimeFramework
+            });
+            resolvedConfig.bff ??= {};
+            resolvedConfig.bff.runtimeFramework = descriptor.runtimeFramework;
+            if (effectEntry) resolvedConfig.bff.effect = {
+                ...resolvedConfig.bff.effect,
+                entry: effectEntry
+            };
+            resolvedConfig.bff.requestId = resolvedConfig.bff.requestId || config?.bff?.requestId || descriptor.requestId || descriptor.native.packageName || 'default';
+            const policy = resolvedConfig.bff.crossProjectPolicy;
+            resolvedConfig.bff.crossProjectPolicy = {
+                ...policy,
+                enabled: policy?.enabled ?? true,
+                requireEnvelope: policy?.requireEnvelope ?? true,
+                requireOperationContext: policy?.requireOperationContext ?? true,
+                requireOperationContextDetails: policy?.requireOperationContextDetails ?? true,
+                requireOperationSchemaHash: policy?.requireOperationSchemaHash ?? true,
+                requireOperationVersion: policy?.requireOperationVersion ?? true,
+                allowUnknownOperations: policy?.allowUnknownOperations ?? false,
+                expectedOperationContracts: {
+                    ...policy?.expectedOperationContracts,
+                    ...descriptor.operationContracts
+                }
+            };
+            return resolvedConfig;
+        }
+    });
+}
+export { createCrossProjectBffPlugin };

package/dist/esm-node/generated-entries.mjs

@@ -0,0 +1,60 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { pathToFileURL } from "node:url";
+import { fs, upath } from "@modern-js/utils";
+import { BFF_REQUEST_RUNTIME } from "./client-artifacts.mjs";
+function registerBffGeneratedEntries(api, metadata) {
+    api.modifyBffGeneratedEntries(async (entries)=>{
+        const { generation } = entries;
+        const details = metadata.get(generation);
+        if (!details) throw new Error('BFF entries require completed operation contract collection.');
+        metadata.delete(generation);
+        const packageJson = await fs.readJSON(upath.join(generation.appDirectory, 'package.json'));
+        const runtimeSpecifier = api.getNormalizedConfig().bff?.runtimeCreateRequest || BFF_REQUEST_RUNTIME;
+        const dependencies = [
+            '@modern-js/plugin-bff-build-extensions',
+            '@modern-js/plugin-bff-extensions'
+        ];
+        const emitsClient = 'hono' === details.runtimeFramework && generation.apiFiles.length > 0;
+        if ('hono' === details.runtimeFramework && (runtimeSpecifier === BFF_REQUEST_RUNTIME || emitsClient && (generation.requestCreator || BFF_REQUEST_RUNTIME) === BFF_REQUEST_RUNTIME)) dependencies.push('@modern-js/runtime-extensions');
+        for (const name of dependencies){
+            const specifier = packageJson.dependencies?.[name] || packageJson.devDependencies?.[name] || fs.readJSONSync(require.resolve(`${name}/package.json`)).version;
+            entries.packageDependencies[name] = specifier;
+        }
+        const descriptor = {
+            native: {
+                packageName: packageJson.name,
+                prefix: generation.prefix,
+                relativeDistPath: upath.normalize(generation.relativeDistPath),
+                relativeApiPath: upath.relative(generation.appDirectory, generation.apiDirectory),
+                relativeLambdaPath: upath.relative(generation.appDirectory, generation.lambdaDirectory)
+            },
+            runtimeFramework: details.runtimeFramework,
+            relativeEffectEntry: details.relativeEffectEntry,
+            requestId: generation.requestId,
+            operationContracts: details.operationContracts
+        };
+        const isModule = 'module' === api.getAppContext().moduleType || 'module' === packageJson.type;
+        entries.plugin = {
+            code: isModule ? `import { createCrossProjectBffPlugin } from '@modern-js/plugin-bff-build-extensions/cross-project';\nexport const crossProjectApiPlugin = () => createCrossProjectBffPlugin(${JSON.stringify(descriptor)});\n` : `'use strict';\nconst { createCrossProjectBffPlugin } = require('@modern-js/plugin-bff-build-extensions/cross-project');\nexports.crossProjectApiPlugin = () => createCrossProjectBffPlugin(${JSON.stringify(descriptor)});\n`,
+            declaration: `import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+export declare const crossProjectApiPlugin: () => CliPlugin<AppTools>;
+`
+        };
+        if ('effect' === details.runtimeFramework) {
+            entries.runtime = null;
+            return entries;
+        }
+        const runtime = JSON.stringify(runtimeSpecifier);
+        const esmRuntime = JSON.stringify(upath.isAbsolute(runtimeSpecifier) ? pathToFileURL(runtimeSpecifier).href : runtimeSpecifier);
+        entries.runtime = {
+            code: isModule ? `import { configure as _configure } from ${esmRuntime};\nimport { createProducerClient } from '@modern-js/plugin-bff-extensions/producer-runtime';\nexport const configure = createProducerClient(_configure, { requestId: ${JSON.stringify(generation.requestId)} });\nexport const initProducerClient = configure;\n` : `'use strict';\nconst { configure: _configure } = require(${runtime});\nconst { createProducerClient } = require('@modern-js/plugin-bff-extensions/producer-runtime');\nconst configure = createProducerClient(_configure, { requestId: ${JSON.stringify(generation.requestId)} });\nexports.configure = configure;\nexports.initProducerClient = configure;\n`,
+            declaration: `type Runtime = typeof import(${runtime});
+export declare const initProducerClient: (options?: Parameters<Runtime['configure']>[0]) => ReturnType<Runtime['configure']>;
+export declare const configure: typeof initProducerClient;
+`
+        };
+        return entries;
+    });
+}
+export { registerBffGeneratedEntries };

package/dist/esm-node/hono-client-codegen.mjs

@@ -0,0 +1,61 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import node_path from "node:path";
+import { buildOperationContractMap, createOperationSchemaHash, deriveOperationVersion } from "@modern-js/server-runtime-extensions/bff-policy/node";
+const REQUEST_RUNTIME = '@modern-js/runtime-extensions/request-policy';
+const modifyClient = (draft, context)=>{
+    const { appDir, requestId } = context.options;
+    draft.requestCreator = context.options.requestCreator || REQUEST_RUNTIME;
+    let version;
+    try {
+        version = require(node_path.resolve(appDir, 'package.json')).version;
+    } catch  {}
+    const operationVersion = deriveOperationVersion(version);
+    const normalizedRequestId = requestId || 'default';
+    const operationContracts = buildOperationContractMap({
+        handlers: [
+            ...context.handlerInfos
+        ],
+        requestId: normalizedRequestId,
+        operationVersion
+    });
+    const operationEntries = context.handlerInfos.map((handlerInfo)=>{
+        const httpMethod = handlerInfo.httpMethod.toUpperCase();
+        return {
+            name: handlerInfo.name,
+            httpMethod,
+            routePath: handlerInfo.routePath,
+            schemaHash: operationContracts[`${httpMethod}:${handlerInfo.routePath}`]?.schemaHash ?? ''
+        };
+    }).sort((a, b)=>`${a.routePath}:${a.httpMethod}:${a.name}`.localeCompare(`${b.routePath}:${b.httpMethod}:${b.name}`));
+    const schemaHash = createOperationSchemaHash(operationEntries, normalizedRequestId);
+    for (const { handlerInfo, optionProperties } of draft.handlers){
+        if ('upload' === handlerInfo.action && !requestId) continue;
+        const method = handlerInfo.httpMethod.toUpperCase();
+        const operationContext = {
+            operationId: handlerInfo.name,
+            routePath: handlerInfo.routePath,
+            method,
+            schemaHash: operationContracts[`${method}:${handlerInfo.routePath}`]?.schemaHash ?? '',
+            operationVersion
+        };
+        optionProperties.push(`operationContext: ${JSON.stringify(operationContext)}`);
+    }
+    if (requestId) {
+        draft.imports.push(`import * as requestRuntime from ${JSON.stringify(draft.requestCreator)};`, 'import { createProducerClient } from "@modern-js/plugin-bff-extensions/producer-runtime";');
+        draft.statements.push(`export const initProducerClient = (options = {}) => {
+  const configure = requestRuntime.configure;
+  if (typeof configure !== 'function') {
+    console.warn('[modernjs] Compatibility request creator path does not expose configure(); use default @modern-js/create-request or migrate the compatibility path.');
+    return undefined;
+  }
+  return createProducerClient(configure, { requestId: ${JSON.stringify(requestId)} })(options);
+};`);
+    }
+    draft.statements.push(`export const operationVersion = ${String(operationVersion)};`, `export const operationSchemaHash = ${JSON.stringify(schemaHash)};`, `export const operationManifest = ${JSON.stringify({
+        operationVersion,
+        schemaHash,
+        operations: operationEntries
+    }, null, 2)};`);
+};
+export { modifyClient };

package/dist/esm-node/index.mjs

@@ -0,0 +1,92 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import "@modern-js/server-runtime-extensions/server-config";
+import { bffPlugin } from "@modern-js/plugin-bff";
+import { fs, upath } from "@modern-js/utils";
+import { BFF_REQUEST_RUNTIME, registerBffClientArtifacts } from "./client-artifacts.mjs";
+import { registerBffCompilation } from "./compile.mjs";
+import { registerBffGeneratedEntries } from "./generated-entries.mjs";
+import { resolveSelfModule } from "./self-module.mjs";
+const src_bffPlugin = ()=>({
+        name: '@modern-js/plugin-bff-build-extensions',
+        usePlugins: [
+            bffPlugin()
+        ],
+        pre: [
+            '@modern-js/plugin-bff'
+        ],
+        setup: (api)=>{
+            const hooks = api.getHooks();
+            for (const name of [
+                'onBeforeBffCompile',
+                'onAfterBffCompile',
+                'modifyBffClientArtifacts',
+                'modifyBffGeneratedEntries'
+            ])if ('function' != typeof hooks[name]?.tap) throw new Error(`Native BFF build hook ${name} is unavailable.`);
+            api.config(()=>({
+                    bff: {
+                        requestCreator: BFF_REQUEST_RUNTIME,
+                        runtimeCreateRequest: BFF_REQUEST_RUNTIME,
+                        clientCodegenPlugin: resolveSelfModule('hono-client-codegen')
+                    }
+                }));
+            const runtimeFramework = api.getConfig()?.bff?.runtimeFramework;
+            if (void 0 !== runtimeFramework && 'hono' !== runtimeFramework && 'effect' !== runtimeFramework) throw new Error(`Unsupported Effect BFF runtime "${runtimeFramework}".`);
+            api.updateAppContext({
+                bffRuntimeFramework: runtimeFramework ?? 'effect'
+            });
+            api._internalServerPlugins(({ plugins })=>{
+                const nativePlugins = plugins.filter((plugin)=>'@modern-js/plugin-bff/server-plugin' === plugin.name);
+                if (1 !== nativePlugins.length) throw new Error('Expected exactly one native BFF server plugin.');
+                const native = nativePlugins[0];
+                const runtimeAdapters = native.options?.runtimeAdapters ?? {};
+                const effect = '@modern-js/plugin-bff-extensions/effect-adapter';
+                const honoRouteBinder = '@modern-js/plugin-bff-extensions/hono/node';
+                if (native.options?.honoRouteBinder !== void 0 && native.options.honoRouteBinder !== honoRouteBinder) throw new Error('The Hono BFF route binder is already configured.');
+                if (void 0 !== runtimeAdapters.effect && runtimeAdapters.effect !== effect) throw new Error('The Effect BFF runtime adapter is already configured.');
+                native.options = {
+                    ...native.options,
+                    honoRouteBinder,
+                    runtimeAdapters: {
+                        ...runtimeAdapters,
+                        effect
+                    }
+                };
+                return {
+                    plugins
+                };
+            });
+            const metadata = new WeakMap();
+            registerBffCompilation(api);
+            registerBffClientArtifacts(api, metadata);
+            registerBffGeneratedEntries(api, metadata);
+            api.modifyBundlerChain(async (chain, { CHAIN_ID })=>{
+                if ('effect' !== api.getAppContext().bffRuntimeFramework) return;
+                const { appDirectory, apiDirectory } = api.getAppContext();
+                const bff = api.getNormalizedConfig().bff;
+                if (!fs.existsSync(apiDirectory) && bff?.effect?.entry === void 0) return;
+                const { resolveEffectEntryFile } = await import("@modern-js/plugin-bff-extensions/effect-source-loader");
+                const entry = resolveEffectEntryFile({
+                    appDir: appDirectory,
+                    apiDir: apiDirectory,
+                    effectEntry: bff?.effect?.entry
+                });
+                if (!entry) throw new Error(`Cannot resolve Effect BFF entry in ${apiDirectory}.`);
+                const canonical = (file)=>upath.normalize(fs.existsSync(file) ? fs.realpathSync(file) : upath.resolve(file));
+                const entryPath = canonical(entry);
+                const isEntry = (resource)=>canonical(resource) === entryPath;
+                chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(isEntry);
+                chain.module.rule('js-bff-api').exclude.add(isEntry);
+                chain.module.rule('js-bff-effect-entry').test(isEntry).use('effect-bff-loader').loader(require.resolve('@modern-js/plugin-bff-extensions/effect-source-loader/rspack-loader')).options({
+                    appDir: appDirectory,
+                    apiDir: apiDirectory,
+                    effectEntry: entry,
+                    prefix: Array.isArray(bff?.prefix) ? bff.prefix[0] : bff?.prefix || '/api',
+                    requestId: bff?.requestId
+                });
+            });
+        }
+    });
+const src = src_bffPlugin;
+export default src;
+export { src_bffPlugin as bffPlugin };

package/dist/esm-node/self-module.mjs

@@ -0,0 +1,15 @@
+import "node:module";
+import { createRequire } from "node:module";
+const selfRequire = createRequire(import.meta.url);
+const resolveSelfModule = (name)=>{
+    for (const extension of [
+        '.js',
+        '.mjs',
+        '.cjs',
+        '.ts'
+    ])try {
+        return selfRequire.resolve(`./${name}${extension}`);
+    } catch  {}
+    return selfRequire.resolve(`@modern-js/plugin-bff-build-extensions/${name}`);
+};
+export { resolveSelfModule };

package/dist/esm-node/server-global-vars.mjs

@@ -0,0 +1,73 @@
+import "node:module";
+import { applyOptionsChain, fs, upath } from "@modern-js/utils";
+import { transform } from "@swc/core";
+const RELEASE_IDENTITY_GLOBAL_NAMES = [
+    'ULTRAMODERN_BUILD_MARKER',
+    'ULTRAMODERN_SOURCE_REVISION',
+    'ULTRAMODERN_RELEASE_VERSION'
+];
+const collectJavaScriptFiles = (directory)=>Promise.resolve().then(()=>fs.readdir(directory, {
+            withFileTypes: true
+        })).then((entries)=>Promise.all(entries.map((entry)=>{
+            const absolutePath = upath.join(directory, entry.name);
+            if (entry.isDirectory()) return collectJavaScriptFiles(absolutePath);
+            return /\.(?:c|m)?js$/u.test(entry.name) ? [
+                absolutePath
+            ] : [];
+        })).then((nested)=>nested.flat()));
+const serializeServerGlobalVars = (options)=>{
+    const globalVars = applyOptionsChain({}, options, {
+        env: 'server',
+        target: 'node'
+    });
+    return Object.fromEntries(Object.entries(globalVars).map(([key, value])=>{
+        let serialized;
+        try {
+            serialized = JSON.stringify(value);
+        } catch (error) {
+            throw new Error(`source.globalVars["${key}"] cannot be serialized exactly for BFF compilation.`, {
+                cause: error
+            });
+        }
+        if (void 0 === serialized) throw new Error(`source.globalVars["${key}"] cannot be serialized exactly for BFF compilation.`);
+        return [
+            key,
+            serialized
+        ];
+    }));
+};
+const transformServerGlobalVars = (outputDirectories, globalVars)=>Promise.resolve().then(()=>{
+        if (0 === Object.keys(globalVars).length) return;
+        return Promise.all(outputDirectories.map((directory)=>fs.pathExists(directory).then((directoryExists)=>directoryExists ? directory : void 0))).then((existingDirectories)=>{
+            const filesPromise = Promise.all(existingDirectories.filter((directory)=>void 0 !== directory).map(collectJavaScriptFiles)).then((files)=>files.flat());
+            const releaseIdentityBanner = RELEASE_IDENTITY_GLOBAL_NAMES.every((name)=>Object.hasOwn(globalVars, name)) ? `${RELEASE_IDENTITY_GLOBAL_NAMES.map((name)=>`void ${globalVars[name]};`).join('')}\n` : '';
+            return filesPromise.then((files)=>Promise.all(files.map((filename)=>fs.readFile(filename, 'utf8').then((source)=>{
+                        const sourceMapFilename = `${filename}.map`;
+                        return fs.pathExists(sourceMapFilename).then((sourceMapExists)=>{
+                            const inputSourceMapPromise = sourceMapExists ? fs.readFile(sourceMapFilename, 'utf8') : Promise.resolve(void 0);
+                            return inputSourceMapPromise.then((inputSourceMap)=>transform(`${releaseIdentityBanner}${source}`, {
+                                    filename,
+                                    inputSourceMap,
+                                    sourceMaps: sourceMapExists,
+                                    jsc: {
+                                        parser: {
+                                            syntax: "ecmascript"
+                                        },
+                                        preserveAllComments: true,
+                                        target: 'es2024',
+                                        transform: {
+                                            optimizer: {
+                                                globals: {
+                                                    vars: globalVars
+                                                }
+                                            }
+                                        }
+                                    }
+                                }).then((result)=>fs.writeFile(filename, result.code).then(()=>{
+                                        if (sourceMapExists && void 0 !== result.map && result.map.length > 0) return fs.writeFile(sourceMapFilename, result.map);
+                                    })));
+                        });
+                    }))));
+        }).then(()=>void 0);
+    });
+export { serializeServerGlobalVars, transformServerGlobalVars };

package/dist/types/client-artifacts.d.ts

@@ -0,0 +1,10 @@
+import type { AppTools, BffGeneration } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import { type OperationContractMap } from '@modern-js/server-runtime-extensions/bff-policy/node';
+export declare const BFF_REQUEST_RUNTIME = "@modern-js/runtime-extensions/request-policy";
+export interface BffGenerationMetadata {
+    runtimeFramework: 'effect' | 'hono';
+    relativeEffectEntry: string;
+    operationContracts: OperationContractMap;
+}
+export declare function registerBffClientArtifacts(api: CLIPluginAPI<AppTools>, metadata: WeakMap<BffGeneration, BffGenerationMetadata>): void;

package/dist/types/compile.d.ts

@@ -0,0 +1,3 @@
+import type { AppTools } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+export declare function registerBffCompilation(api: CLIPluginAPI<AppTools>): void;

package/dist/types/cross-project.d.ts

@@ -0,0 +1,11 @@
+import '@modern-js/server-runtime-extensions/server-config';
+import { type CrossProjectApiPluginOptions } from '@modern-js/plugin-bff/cross-project';
+import type { OperationContractMap } from '@modern-js/server-runtime-extensions/bff-policy/node';
+export interface CrossProjectBffDescriptor {
+    native: Omit<CrossProjectApiPluginOptions, 'modifyResolvedConfig'>;
+    runtimeFramework: 'hono' | 'effect';
+    relativeEffectEntry: string;
+    requestId: string;
+    operationContracts: OperationContractMap;
+}
+export declare function createCrossProjectBffPlugin(descriptor: CrossProjectBffDescriptor): import("@modern-js/app-tools").CliPlugin<Required<import("@modern-js/plugin").CLIPluginExtends<import("@modern-js/app-tools").AppToolsUserConfig, import("@modern-js/app-tools").AppToolsNormalizedConfig<import("@modern-js/app-tools").AppToolsUserConfig>, import("@modern-js/app-tools").AppToolsExtendContext, import("@modern-js/app-tools").AppToolsExtendAPI, import("@modern-js/app-tools").AppToolsExtendHooks, {}, {}>>>;

package/dist/types/generated-entries.d.ts

@@ -0,0 +1,4 @@
+import type { AppTools, BffGeneration } from '@modern-js/app-tools';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import { type BffGenerationMetadata } from './client-artifacts.js';
+export declare function registerBffGeneratedEntries(api: CLIPluginAPI<AppTools>, metadata: WeakMap<BffGeneration, BffGenerationMetadata>): void;

package/dist/types/hono-client-codegen.d.ts

@@ -0,0 +1,2 @@
+import type { ClientCodegenPlugin } from '@modern-js/bff-core';
+export declare const modifyClient: ClientCodegenPlugin;

package/dist/types/index.d.ts

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

package/dist/types/self-module.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Resolve a file this package ships alongside the calling module.
+ *
+ * Resolving it by this package's own public name (`@modern-js/plugin-bff-build-extensions/<name>`)
+ * only works where the package can see itself in a `node_modules` directory —
+ * under pnpm's isolated layout it is anchored in its own `.pnpm` directory and
+ * the lookup fails for a consumer, surfacing as an opaque `require.resolve`
+ * error in the middle of a build. A sibling lookup works in every layout:
+ * source (`src/*.ts`), CommonJS (`dist/cjs/*.js`) and ESM (`dist/esm-node/*.mjs`)
+ * all place these files next to each other.
+ */
+export declare const resolveSelfModule: (name: string) => string;

package/dist/types/server-global-vars.d.ts

@@ -0,0 +1,6 @@
+import type { AppTools } from '@modern-js/app-tools';
+type SerializedGlobalVars = Record<string, string>;
+type ServerGlobalVarsOptions = NonNullable<NonNullable<AppTools['config']>['source']>['globalVars'];
+export declare const serializeServerGlobalVars: (options: ServerGlobalVarsOptions) => SerializedGlobalVars;
+export declare const transformServerGlobalVars: (outputDirectories: string[], globalVars: SerializedGlobalVars) => Promise<undefined>;
+export {};

package/package.json

@@ -1,16 +1,112 @@
 {
-  "name": "@bleedingdev/modern-js-plugin-bff-build-extensions",
-  "version": "0.0.0",
-  "description": "Package-name registration for the forthcoming UltraModern.js release. This setup version contains no runtime implementation.",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/BleedingDev/ultramodern.js.git"
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
   },
+  "license": "MIT",
+  "version": "3.9.0-ultramodern.10",
   "files": [
-    "README.md"
+    "dist",
+    "src"
   ],
+  "engines": {
+    "node": ">=26.7.0"
+  },
+  "sideEffects": false,
   "publishConfig": {
     "access": "public"
+  },
+  "name": "@bleedingdev/modern-js-plugin-bff-build-extensions",
+  "description": "Fork-owned BFF build lifecycle, instrumentation, and producer SDK composition.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/cli/plugin-bff-build-extensions"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm-node/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    },
+    "./cross-project": {
+      "types": "./dist/types/cross-project.d.ts",
+      "node": {
+        "import": "./dist/esm-node/cross-project.mjs",
+        "require": "./dist/cjs/cross-project.js"
+      },
+      "default": "./dist/cjs/cross-project.js"
+    },
+    "./package.json": "./package.json",
+    "./hono-client-codegen": {
+      "types": "./dist/types/hono-client-codegen.d.ts",
+      "node": {
+        "import": "./dist/esm-node/hono-client-codegen.mjs",
+        "require": "./dist/cjs/hono-client-codegen.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "cross-project": [
+        "./dist/types/cross-project.d.ts",
+        "./src/cross-project.ts"
+      ],
+      "hono-client-codegen": [
+        "./dist/types/hono-client-codegen.d.ts",
+        "./src/hono-client-codegen.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@modern-js/bff-core": "npm:@bleedingdev/modern-js-bff-core@3.9.0-ultramodern.10",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.10",
+    "@modern-js/plugin-bff": "npm:@bleedingdev/modern-js-plugin-bff@3.9.0-ultramodern.10",
+    "@modern-js/plugin-bff-extensions": "npm:@bleedingdev/modern-js-plugin-bff-extensions@3.9.0-ultramodern.10",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.10",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.10",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.10",
+    "@swc/core": "1.16.2"
+  },
+  "peerDependencies": {
+    "@effect/opentelemetry": "4.0.0-rc.112",
+    "@modern-js/app-tools": "3.9.0-ultramodern.10",
+    "effect": "4.0.0-rc.112"
+  },
+  "peerDependenciesMeta": {
+    "@effect/opentelemetry": {
+      "optional": true
+    },
+    "effect": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@effect/opentelemetry": "4.0.0-rc.112",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.10",
+    "@modern-js/bff-effect": "npm:@bleedingdev/modern-js-bff-effect@3.9.0-ultramodern.10",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.10",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.10",
+    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.0-ultramodern.10",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.10",
+    "@rsbuild/core": "2.2.3",
+    "@rslib/core": "1.0.0",
+    "@scripts/rstest-config": "2.66.0",
+    "@types/node": "^26.4.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "effect": "4.0.0-rc.112",
+    "esbuild": "^0.28.2",
+    "zod": "^4.5.4"
+  },
+  "scripts": {
+    "dev": "rslib build --watch",
+    "build": "rslib build",
+    "test": "rstest"
   }
 }

package/src/client-artifacts.ts

@@ -0,0 +1,87 @@
+import type {
+  AppTools,
+  BffClientArtifacts,
+  BffGeneration,
+} from '@modern-js/app-tools';
+import { ApiRouter } from '@modern-js/bff-core';
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import {
+  buildOperationContractMap,
+  deriveOperationVersion,
+  type OperationContractMap,
+} from '@modern-js/server-runtime-extensions/bff-policy/node';
+import { fs, upath as path } from '@modern-js/utils';
+
+export const BFF_REQUEST_RUNTIME =
+  '@modern-js/runtime-extensions/request-policy';
+
+export interface BffGenerationMetadata {
+  runtimeFramework: 'effect' | 'hono';
+  relativeEffectEntry: string;
+  operationContracts: OperationContractMap;
+}
+
+export function registerBffClientArtifacts(
+  api: CLIPluginAPI<AppTools>,
+  metadata: WeakMap<BffGeneration, BffGenerationMetadata>,
+) {
+  api.modifyBffClientArtifacts(async (context: BffClientArtifacts) => {
+    const { generation } = context;
+    const config = api.getNormalizedConfig();
+    if (api.getAppContext().bffRuntimeFramework === 'effect') {
+      const { resolveEffectOperationContracts, resolveEffectEntryPaths } =
+        await import('@modern-js/plugin-bff-extensions/effect-source-loader');
+      const { sourceEffectEntry, relativeEffectEntry } =
+        resolveEffectEntryPaths({
+          appDir: generation.appDirectory,
+          apiDir: generation.apiDirectory,
+          effectEntry: config.bff?.effect?.entry,
+        });
+      if (!sourceEffectEntry)
+        throw new Error(
+          `Cannot resolve Effect BFF entry in ${generation.apiDirectory}.`,
+        );
+      const operationContracts = await resolveEffectOperationContracts({
+        appDir: generation.appDirectory,
+        resourcePath: sourceEffectEntry,
+        prefix: generation.prefix,
+        requestId: generation.requestId,
+      });
+      if (operationContracts === null) {
+        throw new Error(
+          `Cannot resolve exported Effect HttpApi in ${sourceEffectEntry}.`,
+        );
+      }
+      metadata.set(generation, {
+        runtimeFramework: 'effect',
+        relativeEffectEntry,
+        operationContracts,
+      });
+    } else {
+      const router = new ApiRouter({
+        appDir: generation.appDirectory,
+        apiDir: generation.apiDirectory,
+        lambdaDir: generation.lambdaDirectory,
+        prefix: generation.prefix,
+        httpMethodDecider: generation.httpMethodDecider,
+        isBuild: true,
+      });
+      const packageJson = await fs.readJSON(
+        path.join(generation.appDirectory, 'package.json'),
+      );
+      const operationContracts = generation.existLambda
+        ? buildOperationContractMap({
+            handlers: await router.getApiHandlers(),
+            requestId: generation.requestId,
+            operationVersion: deriveOperationVersion(packageJson.version),
+          })
+        : {};
+      metadata.set(generation, {
+        runtimeFramework: 'hono',
+        relativeEffectEntry: '',
+        operationContracts,
+      });
+    }
+    return context;
+  });
+}