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

package/dist/esm/runtime/hono/adapter.mjs

@@ -1,5 +1,4 @@
-import { Hono, run } from "@modern-js/server-core";
-import { isProd, logger } from "@modern-js/utils";
+import { logger } from "@modern-js/utils";
 import createHonoRoutes from "../../utils/createHonoRoutes.mjs";
 import { checkCrossProjectPolicyResponse, resolveAdapterCrossProjectPolicy } from "../../utils/crossProjectServerPolicy.mjs";
 import { createSafeFailureResponse } from "../safe-failure.mjs";
@@ -8,17 +7,9 @@ const before = [
     'custom-server-middleware',
     'render'
 ];
-const kParentHonoVars = Symbol.for('modernjs.hono.parentVars');
 class HonoAdapter {
-    wrapInArray(handler) {
-        if (Array.isArray(handler)) return handler;
-        return [
-            handler
-        ];
-    }
     constructor(api){
         this.apiMiddleware = [];
-        this.apiServer = null;
         this.isHono = true;
         this.prefix = '/api';
         this.setHandlers = async ()=>{
@@ -29,7 +20,7 @@ class HonoAdapter {
                     name: 'hono-bff-api',
                     path,
                     method,
-                    handler,
+                    handler: this.withErrorBoundary(handler),
                     order: 'post',
                     before: before
                 }));
@@ -50,85 +41,47 @@ class HonoAdapter {
                 });
             }
         };
-        this.registerApiRoutes = async ()=>{
-            if (!this.isHono) return;
-            this.apiServer = new Hono();
-            this.apiServer.use('*', run);
-            this.apiServer.use('*', async (c, next)=>{
-                const nodeReq = c.env?.node?.req;
-                const parentVars = nodeReq?.[kParentHonoVars];
-                if (parentVars && 'object' == typeof parentVars) {
-                    delete nodeReq[kParentHonoVars];
-                    for (const [key, value] of Object.entries(parentVars))if (void 0 === c.get(key)) c.set(key, value);
-                }
-                await next();
-            });
-            this.apiMiddleware.forEach(({ path = '*', method = 'all', handler })=>{
-                const handlers = this.wrapInArray(handler);
-                if (0 === handlers.length) return;
-                const firstHandler = handlers[0];
-                const restHandlers = handlers.slice(1);
-                const m = method;
-                const server = this.apiServer;
-                if (!server) return;
-                const register = server[m];
-                register.call(server, path, firstHandler, ...restHandlers);
-            });
-            this.apiServer.onError(async (err, c)=>{
-                try {
-                    const serverConfig = this.api.getServerConfig();
-                    const onErrorHandler = serverConfig?.onError;
-                    if (onErrorHandler) {
-                        const result = await onErrorHandler(err, c);
-                        if (result instanceof Response) return result;
-                    } else logger.error(err);
-                } catch (configError) {
-                    logger.error(`Error in serverConfig.onError handler: ${configError}`);
-                }
-                return createSafeFailureResponse(err);
-            });
-        };
-        this.registerMiddleware = async (options)=>{
-            const { prefix } = options;
+        this.registerMiddleware = async (options = {})=>{
             const { bffRuntimeFramework } = this.api.getServerContext();
             if ('hono' !== bffRuntimeFramework) {
                 this.isHono = false;
                 return;
             }
+            const { prefix } = options;
             this.prefix = prefix || this.prefix;
             const { middlewares: globalMiddlewares } = this.api.getServerContext();
             await this.setHandlers();
-            if (isProd()) globalMiddlewares.push(...this.apiMiddleware);
-            else {
-                await this.registerApiRoutes();
-                const dynamicApiMiddleware = {
-                    name: 'dynamic-bff-handler',
-                    path: `${prefix}/*`,
-                    method: 'all',
-                    order: 'post',
-                    before: before,
-                    handler: async (c, next)=>{
-                        if (this.apiServer) {
-                            const nodeReq = c.env?.node?.req;
-                            if (nodeReq) {
-                                const parentVars = c?.var;
-                                nodeReq[kParentHonoVars] = parentVars && 'object' == typeof parentVars ? {
-                                    ...parentVars
-                                } : parentVars;
-                            }
-                            const response = await this.apiServer.fetch(c.req.raw, c.env);
-                            if (404 !== response.status) return new Response(response.body, response);
-                        }
-                        await next();
-                    }
-                };
-                globalMiddlewares.push(dynamicApiMiddleware);
+            globalMiddlewares.push(...this.apiMiddleware);
+        };
+        this.handleRouteError = async (error, c)=>{
+            try {
+                const onErrorHandler = this.api.getServerConfig()?.onError;
+                if (onErrorHandler) {
+                    const result = await onErrorHandler(error, c);
+                    if (result instanceof Response) return result;
+                } else logger.error(error);
+            } catch (configError) {
+                logger.error(`Error in serverConfig.onError handler: ${configError}`);
             }
+            return createSafeFailureResponse(error);
         };
-        this.onApiHandlersUpdated = async ()=>{
-            if (!this.isHono) return;
-            await this.setHandlers();
-            await this.registerApiRoutes();
+        this.withErrorBoundary = (handler)=>{
+            const handlers = Array.isArray(handler) ? handler : [
+                handler
+            ];
+            const [firstHandler, ...restHandlers] = handlers;
+            if (!firstHandler) return handler;
+            const boundary = async (c, next)=>{
+                try {
+                    return await firstHandler(c, next);
+                } catch (error) {
+                    return this.handleRouteError(error, c);
+                }
+            };
+            return Array.isArray(handler) ? [
+                boundary,
+                ...restHandlers
+            ] : boundary;
         };
         this.api = api;
     }

package/dist/esm/runtime/safe-failure.mjs

@@ -6,6 +6,7 @@ const SAFE_FAILURE_CODES = {
     500: 'INTERNAL_SERVER_ERROR',
     503: 'SERVICE_UNAVAILABLE'
 };
+const INVALID_HTTP_HEADER_VALUE = /[\0-\x08\x0a-\x1f\x7f]/u;
 const readErrorProperty = (error, key)=>{
     if ('object' != typeof error || null === error || !(key in error)) return;
     return error[key];
@@ -18,7 +19,7 @@ const normalizeRetryAfter = (value)=>{
     if ('number' == typeof value && Number.isFinite(value) && value >= 0) return String(Math.ceil(value));
     if ('string' == typeof value) {
         const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : void 0;
+        return trimmed.length > 0 && !INVALID_HTTP_HEADER_VALUE.test(trimmed) ? trimmed : void 0;
     }
     if (value instanceof Date) return value.toUTCString();
 };

package/dist/esm/server.mjs

@@ -1,15 +1,17 @@
 import { ApiRouter } from "@modern-js/bff-core";
 import { API_DIR, isFunction, isWebOnly } from "@modern-js/utils";
 import path from "path";
-import { EffectAdapter } from "./runtime/effect/adapter.mjs";
 import { HonoAdapter } from "./runtime/hono/adapter.mjs";
-const RUNTIME_ADAPTER_FACTORIES = {
-    hono: [
-        (api)=>new HonoAdapter(api)
-    ],
-    effect: [
-        (api)=>new EffectAdapter(api)
-    ]
+const RUNTIME_ADAPTER_LOADERS = {
+    hono: async (api)=>[
+            new HonoAdapter(api)
+        ],
+    effect: async (api)=>{
+        const { EffectAdapter } = await import("./runtime/effect/adapter.mjs");
+        return [
+            new EffectAdapter(api)
+        ];
+    }
 };
 const normalizePrefixList = (prefix)=>{
     if (Array.isArray(prefix)) return prefix.filter(Boolean);
@@ -22,9 +24,6 @@ function resolveRuntimeFramework(runtimeFramework) {
     return 'hono' === runtimeFramework ? 'hono' : 'effect';
 }
 class Storage {
-    reset() {
-        this.middlewares = [];
-    }
     constructor(){
         this.middlewares = [];
     }
@@ -36,7 +35,6 @@ const server = ()=>({
             let apiRouter = null;
             const appContext = api.getServerContext();
             const runtimeFramework = resolveRuntimeFramework(appContext.bffRuntimeFramework);
-            const runtimeAdapters = RUNTIME_ADAPTER_FACTORIES[runtimeFramework].map((createAdapter)=>createAdapter(api));
             api.onPrepare(async ()=>{
                 const appContext = api.getServerContext();
                 const { render } = appContext;
@@ -82,29 +80,20 @@ const server = ()=>({
                         ]
                     });
                 }
+                const runtimeAdapters = await RUNTIME_ADAPTER_LOADERS[runtimeFramework](api);
                 await Promise.all(runtimeAdapters.map((adapter)=>adapter.registerMiddleware({
                         prefix,
                         enableHandleWeb
                     })));
             });
             api.onReset(async ({ event })=>{
-                storage.reset();
-                const appContext = api.getServerContext();
-                const { middlewares } = storage;
-                api.updateServerContext({
-                    ...appContext,
-                    apiMiddlewares: middlewares
-                });
-                if ('file-change' === event.type) {
-                    if ('hono' === runtimeFramework && apiRouter) {
-                        const apiHandlerInfos = await apiRouter.getApiHandlers();
-                        const appContext = api.getServerContext();
-                        api.updateServerContext({
-                            ...appContext,
-                            apiHandlerInfos
-                        });
-                    }
-                    await Promise.all(runtimeAdapters.map((adapter)=>adapter.onApiHandlersUpdated?.()));
+                if ('file-change' === event.type && apiRouter) {
+                    const appContext = api.getServerContext();
+                    const apiHandlerInfos = await apiRouter.getApiHandlers();
+                    api.updateServerContext({
+                        ...appContext,
+                        apiHandlerInfos
+                    });
                 }
             });
             const prepareApiServer = async (input, next)=>{

package/dist/esm/utils/client-generator/files.mjs

@@ -0,0 +1,68 @@
+import { fs } from "@modern-js/utils";
+import path from "path";
+const API_DIR = 'api';
+const PLUGIN_DIR = 'plugin';
+const RUNTIME_DIR = 'runtime';
+const CLIENT_DIR = 'client';
+const EXPORT_PREFIX = `./${API_DIR}/`;
+const TYPE_PREFIX = `${API_DIR}/`;
+const GENERATED_RUNTIME_DIRS = [
+    CLIENT_DIR,
+    PLUGIN_DIR,
+    RUNTIME_DIR
+];
+const toPosixPath = (p)=>p.replace(/\\/g, '/');
+const posixJoin = (...args)=>toPosixPath(path.join(...args));
+function createFileDetails(options) {
+    const { appDirectory, baseDirectory, resourcePath, source, relativeDistPath } = options;
+    const relativePath = path.relative(baseDirectory, resourcePath);
+    const parsedPath = path.parse(relativePath);
+    const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
+    const absTargetDir = path.resolve(targetDir);
+    const relativePathFromAppDirectory = path.relative(appDirectory, path.dirname(resourcePath));
+    const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
+    return {
+        resourcePath,
+        source,
+        targetDir,
+        name: parsedPath.name,
+        absTargetDir,
+        relativeTargetDistDir: `./${typesFilePath}`,
+        exportKey: toPosixPath(path.join(parsedPath.dir, parsedPath.name))
+    };
+}
+async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
+    const filesList = [];
+    async function readFiles(currentPath) {
+        const entries = await fs.readdir(currentPath, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if ('_app.ts' === entry.name) continue;
+            const resourcePath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) await readFiles(resourcePath);
+            else {
+                const source = await fs.readFile(resourcePath, 'utf8');
+                filesList.push(createFileDetails({
+                    appDirectory,
+                    baseDirectory: directory,
+                    resourcePath,
+                    source,
+                    relativeDistPath
+                }));
+            }
+        }
+    }
+    await readFiles(directory);
+    return filesList;
+}
+async function writeTargetFile(absTargetDir, content) {
+    await fs.mkdir(path.dirname(absTargetDir), {
+        recursive: true
+    });
+    await fs.writeFile(absTargetDir, content);
+}
+async function copyFiles(from, to) {
+    if (await fs.pathExists(from)) await fs.copy(toPosixPath(from), toPosixPath(to));
+}
+export { API_DIR, CLIENT_DIR, EXPORT_PREFIX, GENERATED_RUNTIME_DIRS, PLUGIN_DIR, RUNTIME_DIR, TYPE_PREFIX, copyFiles, createFileDetails, posixJoin, readDirectoryFiles, toPosixPath, writeTargetFile };

package/dist/esm/utils/client-generator/generate.mjs

@@ -0,0 +1,88 @@
+import { generateClient } from "@modern-js/bff-core";
+import { fs, logger } from "@modern-js/utils";
+import path from "path";
+import { generateEffectClient, resolveEffectEntryFile } from "../effectClientGenerator.mjs";
+import { CLIENT_DIR, copyFiles, createFileDetails, readDirectoryFiles, writeTargetFile } from "./files.mjs";
+import { getPackageName } from "./package-json.mjs";
+import { setPackage, writeClientModuleBoundary } from "./write-package.mjs";
+async function clientGenerator(draftOptions) {
+    const generatedClientDir = path.resolve(draftOptions.appDir, draftOptions.relativeDistPath, CLIENT_DIR);
+    await fs.remove(generatedClientDir);
+    const requestId = getPackageName(draftOptions.appDir) || process.env.npm_package_name;
+    const lambdaSourceList = draftOptions.existLambda ? await readDirectoryFiles(draftOptions.appDir, draftOptions.lambdaDir, draftOptions.relativeDistPath) : [];
+    const generatedSourceList = [
+        ...lambdaSourceList
+    ];
+    const getClitentCode = async (resourcePath, source)=>{
+        const warning = `The file ${resourcePath} is not allowed to be imported in src directory, only API definition files are allowed.`;
+        if (!draftOptions.existLambda) return void logger.warn(warning);
+        const options = {
+            prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+            appDir: draftOptions.appDir,
+            apiDir: draftOptions.apiDir,
+            lambdaDir: draftOptions.lambdaDir,
+            port: Number(draftOptions.port),
+            source,
+            resourcePath,
+            target: 'bundle',
+            httpMethodDecider: draftOptions.httpMethodDecider,
+            requestCreator: draftOptions.requestCreator,
+            requestId
+        };
+        const { lambdaDir } = draftOptions;
+        if (!resourcePath.startsWith(lambdaDir)) return void logger.warn(warning);
+        const result = await generateClient(options);
+        return result;
+    };
+    try {
+        for (const source of lambdaSourceList){
+            const code = await getClitentCode(source.resourcePath, source.source);
+            if (code?.value) {
+                await writeTargetFile(source.absTargetDir, code.value);
+                await copyFiles(source.relativeTargetDistDir, source.targetDir.replace("js", 'd.ts'));
+            }
+        }
+        if ('effect' === draftOptions.bffRuntimeFramework) {
+            const effectEntryFile = resolveEffectEntryFile({
+                appDir: draftOptions.appDir,
+                apiDir: draftOptions.apiDir,
+                effectEntry: draftOptions.effectEntry
+            });
+            if (effectEntryFile) {
+                const effectSource = await fs.readFile(effectEntryFile, 'utf8');
+                const effectFileDetails = createFileDetails({
+                    appDirectory: draftOptions.appDir,
+                    baseDirectory: draftOptions.apiDir,
+                    resourcePath: effectEntryFile,
+                    source: effectSource,
+                    relativeDistPath: draftOptions.relativeDistPath
+                });
+                const effectClientArtifacts = await generateEffectClient({
+                    appDir: draftOptions.appDir,
+                    apiDir: draftOptions.apiDir,
+                    resourcePath: effectEntryFile,
+                    prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+                    port: Number(draftOptions.port),
+                    target: 'bundle',
+                    requestCreator: draftOptions.requestCreator,
+                    httpMethodDecider: draftOptions.httpMethodDecider,
+                    dataPlatformBatch: draftOptions.effectDataPlatformBatch
+                });
+                if (effectClientArtifacts) {
+                    const targetTypeFile = effectFileDetails.targetDir.replace(/\.js$/, '.d.ts');
+                    await writeTargetFile(effectFileDetails.absTargetDir, effectClientArtifacts.code);
+                    await writeTargetFile(path.resolve(targetTypeFile), effectClientArtifacts.declaration);
+                    generatedSourceList.push(effectFileDetails);
+                }
+            }
+        }
+        logger.info("Client bundle generate succeed");
+    } catch (error) {
+        logger.error(`Client bundle generate failed: ${error}`);
+    }
+    if (generatedSourceList.length > 0) await writeClientModuleBoundary(draftOptions.appDir, draftOptions.relativeDistPath);
+    await setPackage(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
+}
+const generate = clientGenerator;
+export default generate;
+export { clientGenerator };

package/dist/esm/utils/client-generator/index.mjs

@@ -0,0 +1,4 @@
+export { copyFiles, createFileDetails, readDirectoryFiles, writeTargetFile } from "./files.mjs";
+export { clientGenerator, default } from "./generate.mjs";
+export { getClientPackageName, getPackageName, mergePackageJson } from "./package-json.mjs";
+export { setPackage, writeClientModuleBoundary } from "./write-package.mjs";

package/dist/esm/utils/client-generator/package-json.mjs

@@ -0,0 +1,78 @@
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { EXPORT_PREFIX, GENERATED_RUNTIME_DIRS, TYPE_PREFIX, toPosixPath } from "./files.mjs";
+function getPackageName(appDirectory) {
+    try {
+        const packageJsonPath = path.resolve(appDirectory, './package.json');
+        const packageJson = fs.readJSONSync(packageJsonPath);
+        return packageJson.name;
+    } catch  {
+        return;
+    }
+}
+function mergePackageJson(packageJson, files, typesVersion, exports, relativeDistPath) {
+    const distPrefix = toPosixPath(`./${relativeDistPath}/`);
+    const generatedPrefixes = GENERATED_RUNTIME_DIRS.map((dir)=>toPosixPath(`${distPrefix}${dir}/`));
+    const isManagedExportEntry = (value)=>{
+        if (!value) return false;
+        const values = [
+            value.import,
+            value.require,
+            value.types
+        ].filter(Boolean);
+        return values.every((entry)=>generatedPrefixes.some((prefix)=>entry.startsWith(prefix)));
+    };
+    const isManagedTypeEntry = (value)=>Array.isArray(value) && value.length > 0 && value.every((entry)=>generatedPrefixes.some((prefix)=>entry.startsWith(prefix)));
+    const normalizedFiles = [
+        ...new Set(files.map((file)=>toPosixPath(file)))
+    ];
+    const currentFiles = packageJson.files || [];
+    packageJson.files = [
+        ...new Set([
+            ...currentFiles.map((file)=>toPosixPath(file)),
+            ...normalizedFiles
+        ])
+    ];
+    packageJson.typesVersions ??= {};
+    const typesVersions = packageJson.typesVersions;
+    const starTypes = typesVersions['*'] || {};
+    const generatedTypeEntries = typesVersion['*'] || {};
+    const generatedTypeKeys = new Set(Object.keys(generatedTypeEntries));
+    const typeConflicts = Object.entries(starTypes).filter(([key, value])=>{
+        if (!generatedTypeKeys.has(key) && !key.startsWith(TYPE_PREFIX)) return false;
+        const generatedValue = generatedTypeEntries[key];
+        if (generatedValue) return JSON.stringify(value) !== JSON.stringify(generatedValue) && !isManagedTypeEntry(value);
+        return !isManagedTypeEntry(value);
+    }).map(([key])=>key);
+    if (typeConflicts.length > 0) throw new Error(`[plugin-bff] package.json typesVersions conflict on keys: ${typeConflicts.sort().join(', ')}. Rename these keys or move them outside "${TYPE_PREFIX}" namespace.`);
+    Object.keys(starTypes).forEach((key)=>{
+        if (generatedTypeKeys.has(key) || key.startsWith(TYPE_PREFIX)) delete starTypes[key];
+    });
+    typesVersions['*'] = {
+        ...starTypes,
+        ...generatedTypeEntries
+    };
+    packageJson.exports ??= {};
+    const packageExports = packageJson.exports;
+    const generatedExportKeys = new Set(Object.keys(exports));
+    const exportConflicts = Object.entries(packageExports).filter(([key, value])=>{
+        if (!generatedExportKeys.has(key) && !key.startsWith(EXPORT_PREFIX)) return false;
+        const generatedValue = exports[key];
+        if (generatedValue) return JSON.stringify(value) !== JSON.stringify(generatedValue) && !isManagedExportEntry(value);
+        return !isManagedExportEntry(value);
+    }).map(([key])=>key);
+    if (exportConflicts.length > 0) throw new Error(`[plugin-bff] package.json exports conflict on keys: ${exportConflicts.sort().join(', ')}. Rename these exports or move them outside "${EXPORT_PREFIX}" namespace.`);
+    Object.keys(packageExports).forEach((key)=>{
+        if (generatedExportKeys.has(key) || key.startsWith(EXPORT_PREFIX)) delete packageExports[key];
+    });
+    Object.assign(packageExports, exports);
+}
+function getClientPackageName(appDirectory) {
+    const packageName = getPackageName(appDirectory) || path.basename(appDirectory);
+    if (packageName.startsWith('@') && packageName.includes('/')) {
+        const [scope, name] = packageName.split('/');
+        return `${scope}/${name}-bff-client`;
+    }
+    return `${packageName}-bff-client`;
+}
+export { getClientPackageName, getPackageName, mergePackageJson };

package/dist/esm/utils/client-generator/write-package.mjs

@@ -0,0 +1,74 @@
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { API_DIR, CLIENT_DIR, EXPORT_PREFIX, PLUGIN_DIR, RUNTIME_DIR, TYPE_PREFIX, posixJoin, toPosixPath, writeTargetFile } from "./files.mjs";
+import { getClientPackageName, mergePackageJson } from "./package-json.mjs";
+async function writeClientModuleBoundary(appDirectory, relativeDistPath) {
+    await writeTargetFile(path.resolve(appDirectory, relativeDistPath, CLIENT_DIR, 'package.json'), `${JSON.stringify({
+        private: true,
+        name: getClientPackageName(appDirectory),
+        type: 'module'
+    }, null, 2)}\n`);
+}
+async function setPackage(files, appDirectory, relativeDistPath) {
+    const packagePath = path.resolve(appDirectory, './package.json');
+    const packageContent = await fs.readFile(packagePath, 'utf8');
+    const packageJson = JSON.parse(packageContent);
+    const sortedFiles = [
+        ...files
+    ].sort((a, b)=>a.exportKey.localeCompare(b.exportKey));
+    const addFiles = [
+        posixJoin(relativeDistPath, CLIENT_DIR, '**', '*'),
+        posixJoin(relativeDistPath, RUNTIME_DIR, '**', '*'),
+        posixJoin(relativeDistPath, PLUGIN_DIR, '**', '*')
+    ];
+    const typesVersions = {
+        '*': sortedFiles.reduce((acc, file)=>{
+            const typeFilePath = toPosixPath(`./${file.targetDir}`).replace(/\.js$/, '.d.ts');
+            return {
+                ...acc,
+                [toPosixPath(`${TYPE_PREFIX}${file.exportKey}`)]: [
+                    typeFilePath
+                ]
+            };
+        }, {
+            [`${API_DIR}/*`]: [
+                toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.d.ts`)
+            ],
+            [RUNTIME_DIR]: [
+                toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.d.ts`)
+            ],
+            [PLUGIN_DIR]: [
+                toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.d.ts`)
+            ]
+        })
+    };
+    const exports = sortedFiles.reduce((acc, file)=>{
+        const exportKey = `${EXPORT_PREFIX}${file.exportKey}`;
+        const jsFilePath = toPosixPath(`./${file.targetDir}`);
+        return {
+            ...acc,
+            [toPosixPath(exportKey)]: {
+                import: jsFilePath,
+                types: toPosixPath(jsFilePath.replace(/\.js$/, '.d.ts'))
+            }
+        };
+    }, {
+        [toPosixPath(`./${API_DIR}/*`)]: {
+            import: toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.js`),
+            types: toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.d.ts`)
+        },
+        [toPosixPath(`./${PLUGIN_DIR}`)]: {
+            import: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.js`),
+            require: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.js`),
+            types: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.d.ts`)
+        },
+        [toPosixPath(`./${RUNTIME_DIR}`)]: {
+            import: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.js`),
+            require: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.js`),
+            types: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.d.ts`)
+        }
+    });
+    mergePackageJson(packageJson, addFiles, typesVersions, exports, relativeDistPath);
+    await fs.promises.writeFile(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+export { setPackage, writeClientModuleBoundary };