libmodulor 0.18.1 → 0.19.0

package/dist/esm/target/lib/server/ServerBooter.d.ts

@@ -22,5 +22,6 @@ export declare class ServerBooter implements Configurable<S>, Worker<Input, Prom
     constructor(emailManager: EmailManager, fsManager: FSManager, i18nManager: I18nManager, jobManager: JobManager, logger: Logger, productUCsLoader: ProductUCsLoader, serverManager: ServerManager, serverInstaller: ServerInstaller, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
     exec({ appsRootPath, autoMountUCs, srcImporter, }: Input): Promise<void>;
+    private mountUC;
 }
 export {};

package/dist/esm/target/lib/server/ServerBooter.js

@@ -12,7 +12,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'inversify';
 import { ProductUCsLoader } from '../../../product/index.js';
-import { UCExecMode, ucHTTPContract, } from '../../../uc/index.js';
+import { ucHTTPContract, } from '../../../uc/index.js';
+import { shouldMountUC } from './funcs.js';
 import { ServerInstaller } from './ServerInstaller.js';
 let ServerBooter = class ServerBooter {
     emailManager;
@@ -52,53 +53,49 @@ let ServerBooter = class ServerBooter {
         await this.jobManager.init();
         this.logger.info('Verifying email manager');
         await this.emailManager.verify();
-        this.logger.info('Starting');
-        try {
-            await this.serverManager.init();
-            if (autoMountUCs) {
-                const ucs = await this.productUCsLoader.exec({
-                    appsRootPath,
-                    srcImporter,
-                });
-                for await (const uc of ucs) {
-                    const { lifecycle: { server }, sec, } = uc.def;
-                    const contract = ucHTTPContract(uc);
-                    const { mountingPoint } = contract;
-                    if (typeof server !== 'object' ||
-                        server.execMode === UCExecMode.AUTO) {
-                        this.logger.debug(`Not mounting ${mountingPoint}`, {
-                            reason: typeof server !== 'object'
-                                ? 'no ucd.lifecycle.server'
-                                : 'execMode is AUTO',
-                        });
-                        continue;
-                    }
-                    this.logger.info(`Mounting ${mountingPoint}`, {
-                        contract,
-                        sec,
-                    });
-                    await this.ucManager.initServer(uc);
-                    await this.serverManager.mount(uc.appManifest, uc.def, contract);
-                }
+        this.logger.info('Initializing server manager');
+        await this.serverManager.init();
+        if (autoMountUCs) {
+            const ucs = await this.productUCsLoader.exec({
+                appsRootPath,
+                srcImporter,
+            });
+            for await (const uc of ucs) {
+                await this.mountUC(uc);
             }
-            const staticDirPath = this.s().server_static_dir_path;
-            if (staticDirPath) {
-                if (!(await this.fsManager.exists(staticDirPath))) {
-                    throw new Error(`Static dir '${staticDirPath}' does not exist`);
-                }
-                this.logger.info('Mounting static dir', { staticDirPath });
-                await this.serverManager.mountStaticDir(staticDirPath);
-            }
-            const tmpDirPath = this.s().server_tmp_path;
-            if (!(await this.fsManager.exists(tmpDirPath))) {
-                await this.fsManager.mkdir(tmpDirPath);
+        }
+        const staticDirPath = this.s().server_static_dir_path;
+        if (staticDirPath) {
+            if (!(await this.fsManager.exists(staticDirPath))) {
+                throw new Error(`Static dir '${staticDirPath}' does not exist`);
             }
-            await this.serverManager.warmUp();
-            await this.serverManager.start();
+            this.logger.info('Mounting static dir', { staticDirPath });
+            await this.serverManager.mountStaticDir(staticDirPath);
         }
-        catch (err) {
-            this.logger.error(err);
+        const tmpDirPath = this.s().server_tmp_path;
+        if (!(await this.fsManager.exists(tmpDirPath))) {
+            await this.fsManager.mkdir(tmpDirPath);
+        }
+        await this.serverManager.warmUp();
+        await this.serverManager.start();
+    }
+    async mountUC(uc) {
+        const { sec } = uc.def;
+        const contract = ucHTTPContract(uc);
+        const { mountingPoint } = contract;
+        const shouldNotMountReason = shouldMountUC(uc.def);
+        if (shouldNotMountReason) {
+            this.logger.debug(`Not mounting ${mountingPoint}`, {
+                reason: shouldNotMountReason,
+            });
+            return;
         }
+        this.logger.info(`Mounting ${mountingPoint}`, {
+            contract,
+            sec,
+        });
+        await this.ucManager.initServer(uc);
+        await this.serverManager.mount(uc.appManifest, uc.def, contract);
     }
 };
 ServerBooter = __decorate([

package/dist/esm/target/lib/server/ServerManager.d.ts

@@ -38,6 +38,13 @@ export interface ServerManager extends Initializable {
      * @param contract
      */
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    /**
+     * Mount the use case as an endpoint
+     * @param appManifest
+     * @param ucd
+     * @param contract
+     */
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
     /**
      * Mount the static directory at `/`
      * @param dirPath

package/dist/esm/target/lib/server/SyncEdgeWorkerInitializer.d.ts

@@ -0,0 +1,17 @@
+import type { AppUCsLoaderOutput } from '../../../app/index.js';
+import type { I18nManager, JobManager, Logger, Worker } from '../../../std/index.js';
+import type { ServerManager } from './ServerManager.js';
+type Input = {
+    autoMountUCs?: boolean;
+    ucs: AppUCsLoaderOutput;
+};
+export declare class SyncEdgeWorkerInitializer implements Worker<Input, void> {
+    private i18nManager;
+    private jobManager;
+    private logger;
+    private serverManager;
+    constructor(i18nManager: I18nManager, jobManager: JobManager, logger: Logger, serverManager: ServerManager);
+    exec({ autoMountUCs, ucs }: Input): void;
+    private mountUC;
+}
+export {};

package/dist/esm/target/lib/server/SyncEdgeWorkerInitializer.js

@@ -0,0 +1,76 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { ucHTTPContract, } from '../../../uc/index.js';
+import { shouldMountUC } from './funcs.js';
+let SyncEdgeWorkerInitializer = class SyncEdgeWorkerInitializer {
+    i18nManager;
+    jobManager;
+    logger;
+    serverManager;
+    constructor(i18nManager, jobManager, logger, serverManager) {
+        this.i18nManager = i18nManager;
+        this.jobManager = jobManager;
+        this.logger = logger;
+        this.serverManager = serverManager;
+    }
+    exec({ autoMountUCs = true, ucs }) {
+        this.logger.info('Initializing i18n manager');
+        this.i18nManager.initSync();
+        // Not available as a sync method yet
+        // this.logger.info('Installing');
+        // await this.serverInstaller.exec();
+        this.logger.info('Initializing job manager');
+        this.jobManager.initSync();
+        // Not available as a sync method yet
+        // this.logger.info('Verifying email manager');
+        // await this.emailManager.verify();
+        this.logger.info('Initializing server manager');
+        this.serverManager.initSync();
+        if (autoMountUCs) {
+            for (const uc of ucs) {
+                this.mountUC(uc);
+            }
+        }
+    }
+    mountUC(uc) {
+        const { lifecycle, sec } = uc.def;
+        const contract = ucHTTPContract(uc);
+        const { mountingPoint } = contract;
+        const shouldNotMountReason = shouldMountUC(uc.def);
+        if (shouldNotMountReason) {
+            this.logger.debug(`Not mounting ${mountingPoint}`, {
+                reason: shouldNotMountReason,
+            });
+            return;
+        }
+        this.logger.info(`Mounting ${mountingPoint}`, {
+            contract,
+            sec,
+        });
+        if (typeof lifecycle.server === 'object' && lifecycle.server?.init) {
+            throw new Error('lifecycle.server.init is not available in SyncEdgeWorkerInitializer yet');
+            // await this.ucManager.initServer(uc);
+        }
+        this.serverManager.mountSync(uc.appManifest, uc.def, contract);
+    }
+};
+SyncEdgeWorkerInitializer = __decorate([
+    injectable(),
+    __param(0, inject('I18nManager')),
+    __param(1, inject('JobManager')),
+    __param(2, inject('Logger')),
+    __param(3, inject('ServerManager')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], SyncEdgeWorkerInitializer);
+export { SyncEdgeWorkerInitializer };

package/dist/esm/target/lib/server/funcs.d.ts

@@ -0,0 +1,3 @@
+import { type UCDef, type UCInput, type UCOPIBase } from '../../../uc/index.js';
+export type ShouldNotMountReason = string;
+export declare function shouldMountUC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>): ShouldNotMountReason | null;

package/dist/esm/target/lib/server/funcs.js

@@ -0,0 +1,11 @@
+import { UCExecMode, } from '../../../uc/index.js';
+export function shouldMountUC(ucd) {
+    const { lifecycle: { server }, } = ucd;
+    if (typeof server !== 'object') {
+        return 'no ucd.lifecycle.server';
+    }
+    if (server.execMode === UCExecMode.AUTO) {
+        return 'execMode is AUTO';
+    }
+    return null;
+}

package/dist/esm/target/lib/server-express/HelmetMiddlewareBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { RequestHandler } from 'express';
+import type { Worker } from '../../../std/index.js';
+import { CSPDirectivesBuilder } from '../server/CSPDirectivesBuilder.js';
+interface Input {
+}
+type Output = RequestHandler;
+export declare class HelmetMiddlewareBuilder implements Worker<Input, Output> {
+    private cspDirectivesBuilder;
+    constructor(cspDirectivesBuilder: CSPDirectivesBuilder);
+    exec(_input: Input): Output;
+}
+export {};

package/dist/esm/target/lib/server-express/HelmetMiddlewareBuilder.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import helmet from 'helmet';
+import { inject, injectable } from 'inversify';
+import { CSPDirectivesBuilder, } from '../server/CSPDirectivesBuilder.js';
+let HelmetMiddlewareBuilder = class HelmetMiddlewareBuilder {
+    cspDirectivesBuilder;
+    constructor(cspDirectivesBuilder) {
+        this.cspDirectivesBuilder = cspDirectivesBuilder;
+    }
+    exec(_input) {
+        const defaultDirectives = helmet.contentSecurityPolicy.getDefaultDirectives();
+        const { directives } = this.cspDirectivesBuilder.exec({
+            defaultDirectives,
+        });
+        return helmet({
+            contentSecurityPolicy: {
+                directives,
+                useDefaults: false,
+            },
+        });
+    }
+};
+HelmetMiddlewareBuilder = __decorate([
+    injectable(),
+    __param(0, inject(CSPDirectivesBuilder)),
+    __metadata("design:paramtypes", [CSPDirectivesBuilder])
+], HelmetMiddlewareBuilder);
+export { HelmetMiddlewareBuilder };

package/dist/esm/target/lib/server-express/funcs.d.ts

@@ -0,0 +1,15 @@
+import { type Express, type Request, type RequestHandler, type Response } from 'express';
+import fileUpload from 'express-fileupload';
+import type { AppManifest } from '../../../app/index.js';
+import type { File } from '../../../dt/index.js';
+import type { LoggerLevel } from '../../../std/index.js';
+import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../../uc/index.js';
+import type { ServerManagerSettings } from '../server/ServerManager.js';
+import type { ServerRequestHandler, ServerRequestHandlerReq, ServerRequestHandlerRes } from '../server/ServerRequestHandler.js';
+import type { HelmetMiddlewareBuilder } from './HelmetMiddlewareBuilder.js';
+export declare function buildHandler<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract, serverRequestHandler: ServerRequestHandler, ucManager: UCManager): RequestHandler;
+export declare function init(helmetMB: HelmetMiddlewareBuilder, loggerLevel: LoggerLevel, serverTmpPath: ServerManagerSettings['server_tmp_path']): Express;
+export declare function mountHandler(contract: UCHTTPContract, express: Express, handler: RequestHandler): void;
+export declare function toFile(f: fileUpload.UploadedFile): File;
+export declare function toReq(req: Request): ServerRequestHandlerReq;
+export declare function toRes(res: Response): ServerRequestHandlerRes;

package/dist/esm/target/lib/server-express/funcs.js

@@ -0,0 +1,103 @@
+import cookieParser from 'cookie-parser';
+import express, {} from 'express';
+import fileUpload from 'express-fileupload';
+export function buildHandler(appManifest, ucd, contract, serverRequestHandler, ucManager) {
+    const { envelope } = contract;
+    const handler = async (req, res) => {
+        const { body, status } = await serverRequestHandler.exec({
+            appManifest,
+            envelope,
+            req: toReq(req),
+            res: toRes(res),
+            ucd,
+            ucManager,
+        });
+        if (!body) {
+            res.status(status).send();
+            return;
+        }
+        res.status(status).send(body);
+    };
+    return handler;
+}
+export function init(helmetMB, loggerLevel, serverTmpPath) {
+    const app = express();
+    app.use(helmetMB.exec({}));
+    app.use(fileUpload({
+        createParentPath: true,
+        debug: loggerLevel === 'trace',
+        tempFileDir: serverTmpPath,
+        useTempFiles: true,
+    }));
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    app.use(cookieParser());
+    return app;
+}
+export function mountHandler(contract, express, handler) {
+    const { method, path, pathAliases } = contract;
+    const httpMethod = method.toLowerCase();
+    express[httpMethod](path, handler);
+    for (const pathAlias of pathAliases) {
+        express[httpMethod](pathAlias, handler);
+    }
+}
+export function toFile(f) {
+    return {
+        name: f.name,
+        path: f.tempFilePath,
+        type: f.mimetype,
+    };
+}
+export function toReq(req) {
+    return {
+        bodyFromFormData: async () => {
+            // Since express v5, if the request contains only a file, `req.body` is `undefined`, hence the fallback on `{}`
+            const input = req.body ?? {};
+            // files is present when using express-fileupload
+            if ('files' in req && req.files) {
+                for (const [field, value] of Object.entries(req.files)) {
+                    input[field] = Array.isArray(value)
+                        ? value.map(toFile)
+                        : toFile(value);
+                }
+            }
+            for (const [k, v] of Object.entries(input)) {
+                const isMultiple = k.endsWith('[]'); // e.g. 'tags[]': 'Electronic'
+                const key = isMultiple ? k.replaceAll('[]', '') : k;
+                if (isMultiple) {
+                    input[key] = Array.isArray(v) ? v : [v];
+                }
+                else {
+                    input[key] = v;
+                }
+            }
+            return input;
+        },
+        bodyFromJSON: async () => req.body,
+        bodyFromQueryParams: async () => req.query,
+        bodyRaw: req.body,
+        cookie: (name) => req.cookies[name],
+        header: async (name) => {
+            const h = req.headers[name.toLowerCase()];
+            if (Array.isArray(h)) {
+                return h[0];
+            }
+            return h;
+        },
+        method: req.method,
+        secure: req.secure,
+        url: req.url,
+    };
+}
+export function toRes(res) {
+    return {
+        clearCookie: async (name) => {
+            res.clearCookie(name);
+        },
+        redirect: async (location) => res.redirect(location),
+        setCookie: async ({ name, opts, val }) => {
+            res.cookie(name, val, opts);
+        },
+    };
+}

package/dist/esm/target/lib/server-hono/funcs.d.ts

@@ -0,0 +1,10 @@
+import { type Context, type Handler, Hono } from 'hono';
+import type { BlankEnv, Env } from 'hono/types';
+import type { AppManifest } from '../../../app/index.js';
+import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../../uc/index.js';
+import type { ServerRequestHandler, ServerRequestHandlerReq, ServerRequestHandlerRes } from '../server/ServerRequestHandler.js';
+export declare function buildHandler<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract, serverRequestHandler: ServerRequestHandler, ucManager: UCManager, beforeExec?: (c: Context) => Promise<void>): Handler;
+export declare function init<E extends Env = BlankEnv>(): Hono<E>;
+export declare function mountHandler(contract: UCHTTPContract, hono: Hono, handler: Handler): void;
+export declare function toReq(c: Context): ServerRequestHandlerReq;
+export declare function toRes(c: Context): ServerRequestHandlerRes;

package/dist/esm/target/lib/server-hono/funcs.js

@@ -0,0 +1,72 @@
+import { Hono } from 'hono';
+import { deleteCookie, getCookie, setCookie } from 'hono/cookie';
+import { logger } from 'hono/logger';
+import { secureHeaders } from 'hono/secure-headers';
+import { NotFoundError } from '../../../error/index.js';
+import { fromFormData } from '../../../utils/index.js';
+export function buildHandler(appManifest, ucd, contract, serverRequestHandler, ucManager, beforeExec) {
+    const { envelope } = contract;
+    const handler = async (c) => {
+        await beforeExec?.(c);
+        const { body, status } = await serverRequestHandler.exec({
+            appManifest,
+            envelope,
+            req: toReq(c),
+            res: toRes(c),
+            ucd,
+            ucManager,
+        });
+        if (!body) {
+            return c.newResponse(null, status);
+        }
+        return c.json(body, status);
+    };
+    return handler;
+}
+export function init() {
+    const app = new Hono();
+    app.use(secureHeaders());
+    app.use(logger());
+    app.notFound((c) => {
+        const err = new NotFoundError();
+        return c.json(err.toObj(), err.httpStatus);
+    });
+    return app;
+}
+export function mountHandler(contract, hono, handler) {
+    const { method, path, pathAliases } = contract;
+    const httpMethod = method.toLowerCase();
+    if (httpMethod === 'connect' ||
+        httpMethod === 'head' ||
+        httpMethod === 'trace') {
+        throw new Error(`Unsupported HTTP method : ${httpMethod}`);
+    }
+    hono[httpMethod](path, handler);
+    for (const pathAlias of pathAliases) {
+        hono[httpMethod](pathAlias, handler);
+    }
+}
+export function toReq(c) {
+    return {
+        bodyFromFormData: async () => fromFormData(await c.req.formData()),
+        bodyFromJSON: () => c.req.json(),
+        bodyFromQueryParams: async () => c.req.queries(),
+        bodyRaw: c.req.raw,
+        cookie: async (name) => getCookie(c, name),
+        header: async (name) => c.req.header(name),
+        method: c.req.method,
+        secure: c.req.url.startsWith('https://'),
+        url: c.req.url,
+    };
+}
+export function toRes(c) {
+    return {
+        clearCookie: async (name) => {
+            deleteCookie(c, name);
+        },
+        redirect: async (location) => {
+            c.redirect(location);
+        },
+        setCookie: async ({ name, opts, val }) => setCookie(c, name, val, opts),
+    };
+}

package/dist/esm/target/lib/server-node/funcs.d.ts

@@ -0,0 +1,5 @@
+import type { Logger, SettingsManager } from '../../../std/index.js';
+import type { EntrypointsBuilder } from '../server/EntrypointsBuilder.js';
+import type { ListenSettings, Server } from './types.js';
+export declare function listen(server: Server, entrypointsBuilder: EntrypointsBuilder, logger: Logger, settingsManager: SettingsManager<ListenSettings>): void;
+export declare function stop(server: Server): Promise<void>;

package/dist/esm/target/lib/server-node/funcs.js

@@ -0,0 +1,25 @@
+export function listen(server, entrypointsBuilder, logger, settingsManager) {
+    const host = settingsManager.get()('server_binding_host');
+    const port = settingsManager.get()('server_binding_port');
+    server.listen(port, host, () => {
+        logger.info(`Listening on ${entrypointsBuilder.exec().http}`);
+    });
+}
+export async function stop(server) {
+    if (!server?.listening) {
+        return;
+    }
+    // As stated in the docs of `close`, only awaiting `.close` is not enough to make sure all the connections are closed.
+    // Hence the wrapping in a promise, where the callback is called when the 'close' event is emitted.
+    return new Promise((resolve, reject) => {
+        if (!server) {
+            return resolve();
+        }
+        server.close((err) => {
+            if (err) {
+                return reject(err);
+            }
+            resolve();
+        });
+    });
+}

package/dist/esm/target/lib/server-node/types.d.ts

@@ -1,3 +1,5 @@
 import type http from 'node:http';
 import type https from 'node:https';
+import type { ServerManagerSettings } from '../server/ServerManager.js';
 export type Server = http.Server | https.Server;
+export type ListenSettings = Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port'>;

package/dist/esm/target/nextjs-server/NextJSServerManager.d.ts

@@ -5,7 +5,9 @@ import type { ServerManager } from '../lib/server/ServerManager.js';
 export declare class NextJSServerManager implements ServerManager {
     overrideUCManager(_ucManager: UCManager): void;
     init(): Promise<void>;
+    initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(_appManifest: AppManifest, _ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(_appManifest: AppManifest, _ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): void;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/esm/target/nextjs-server/NextJSServerManager.js

@@ -12,9 +12,15 @@ let NextJSServerManager = class NextJSServerManager {
     async init() {
         // Nothing to do
     }
+    initSync() {
+        // Nothing to do
+    }
     async mount(_appManifest, _ucd, _contract) {
         // Nothing to do
     }
+    mountSync(_appManifest, _ucd, _contract) {
+        // Nothing to do
+    }
     async mountStaticDir(_dirPath) {
         // Nothing to do
     }

package/dist/esm/target/node-core-cli/NodeCoreCLIManager.d.ts

@@ -1,12 +1,14 @@
 import { WordingManager } from '../../i18n/index.js';
 import { ProductUCsLoader } from '../../product/index.js';
+import type { I18nManager } from '../../std/index.js';
 import type { CLIManager, Input, Output } from '../lib/cli/CLIManager.js';
 import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
 export declare class NodeCoreCLIManager implements CLIManager {
     private commandExecutor;
+    private i18nManager;
     private productUCsLoader;
     private wordingManager;
-    constructor(commandExecutor: CommandExecutor, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
+    constructor(commandExecutor: CommandExecutor, i18nManager: I18nManager, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
     handleCommand({ appsRootPath, srcImporter, }: Input): Promise<Output>;
     private parseArgsConfig;
 }

package/dist/esm/target/node-core-cli/NodeCoreCLIManager.js

@@ -21,14 +21,17 @@ import { print } from '../lib/cli/renderer.js';
 import { showHelp } from './commands.js';
 let NodeCoreCLIManager = class NodeCoreCLIManager {
     commandExecutor;
+    i18nManager;
     productUCsLoader;
     wordingManager;
-    constructor(commandExecutor, productUCsLoader, wordingManager) {
+    constructor(commandExecutor, i18nManager, productUCsLoader, wordingManager) {
         this.commandExecutor = commandExecutor;
+        this.i18nManager = i18nManager;
         this.productUCsLoader = productUCsLoader;
         this.wordingManager = wordingManager;
     }
     async handleCommand({ appsRootPath, srcImporter, }) {
+        await this.i18nManager.init();
         const command = process.argv[2] ?? '';
         const ucs = await this.productUCsLoader.exec({
             appsRootPath,
@@ -84,10 +87,10 @@ let NodeCoreCLIManager = class NodeCoreCLIManager {
 NodeCoreCLIManager = __decorate([
     injectable(),
     __param(0, inject(CommandExecutor)),
-    __param(1, inject(ProductUCsLoader)),
-    __param(2, inject(WordingManager)),
-    __metadata("design:paramtypes", [CommandExecutor,
-        ProductUCsLoader,
+    __param(1, inject('I18nManager')),
+    __param(2, inject(ProductUCsLoader)),
+    __param(3, inject(WordingManager)),
+    __metadata("design:paramtypes", [CommandExecutor, Object, ProductUCsLoader,
         WordingManager])
 ], NodeCoreCLIManager);
 export { NodeCoreCLIManager };

package/dist/esm/target/node-express-server/NodeExpressServerManager.d.ts

@@ -7,8 +7,9 @@ import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { HelmetMiddlewareBuilder } from './middlewares/HelmetMiddlewareBuilder.js';
-type S = Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port' | 'server_tmp_path'>;
+import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
+import type { ListenSettings } from '../lib/server-node/types.js';
+type S = ListenSettings & Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_tmp_path'>;
 export declare class NodeExpressServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
@@ -25,14 +26,14 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     getRuntime(): Express;
     overrideUCManager(ucManager: UCManager): void;
     init(): Promise<void>;
+    initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     warmUp(): Promise<void>;
     private createServer;
-    private toFile;
-    private toReq;
-    private toRes;
+    private mountCommon;
 }
 export {};