libmodulor 0.25.0 → 0.26.0

package/dist/esm/std/index.js

@@ -15,6 +15,7 @@ export * from './JobManager.js';
 export * from './JWTManager.js';
 export * from './LLMManager.js';
 export * from './Logger.js';
+export * from './lib/settings.js';
 export * from './PromptManager.js';
 export * from './SettingsManager.js';
 export * from './ShellCommandExecutor.js';

package/dist/esm/std/lib/settings.d.ts

@@ -0,0 +1,5 @@
+import type { StringKeys } from '../../utils/index.js';
+import type { Settings } from '../SettingsManager.js';
+export declare function unsafeDefaultSetting(suffix?: string): string;
+export declare function assertSettingNotUnsafe<S extends Settings, K extends StringKeys<S> = StringKeys<S>>(key: K, value: unknown): void;
+export declare function checkSettings<S extends Settings>(settings: S, throwIfViolations: boolean): void;

package/dist/esm/std/lib/settings.js

@@ -0,0 +1,39 @@
+const UNSAFE_SETTING = 'UNSAFE_CHANGE_ME';
+export function unsafeDefaultSetting(suffix = '') {
+    return `${UNSAFE_SETTING}${suffix}`;
+}
+export function assertSettingNotUnsafe(key, value) {
+    if (typeof value === 'string' && value.startsWith(UNSAFE_SETTING)) {
+        throw new Error(`"${key}" still has the unsafe default value. Please change it !`);
+    }
+    if (Array.isArray(value)) {
+        for (const v of value) {
+            assertSettingNotUnsafe(key, v);
+        }
+    }
+    if (typeof value === 'object' && value !== null) {
+        for (const [_k, v] of Object.entries(value)) {
+            assertSettingNotUnsafe(key, v);
+        }
+    }
+}
+export function checkSettings(settings, throwIfViolations) {
+    const violations = [];
+    for (const [k, v] of Object.entries(settings)) {
+        try {
+            assertSettingNotUnsafe(k, v);
+        }
+        catch (err) {
+            violations.push(err.message);
+        }
+    }
+    if (violations.length > 0) {
+        // 1m  : bold ; 33m : yellow/orange ; 0m  : reset
+        const message = `\x1b[1m\x1b[33m[WARNING] THE SETTINGS ARE NOT SAFE (THIS WILL THROW IN PROD) :\n${violations.join('\n')}\x1b[0m`;
+        if (throwIfViolations) {
+            throw new Error(message);
+        }
+        // biome-ignore lint/suspicious/noConsole: we want it
+        console.warn(message);
+    }
+}

package/dist/esm/target/edge-worker-hono-server/SyncEdgeWorkerHonoServerManager.d.ts

@@ -3,6 +3,7 @@ import type { AppManifest } from '../../app/index.js';
 import type { DirPath } from '../../dt/index.js';
 import type { Configurable, SettingsManager } from '../../std/index.js';
 import type { UCDataStore, UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 export interface SyncEdgeWorkerHonoServerManagerSettings {
@@ -10,12 +11,13 @@ export interface SyncEdgeWorkerHonoServerManagerSettings {
 }
 type S = SyncEdgeWorkerHonoServerManagerSettings;
 export declare class SyncEdgeWorkerHonoServerManager implements Configurable<S>, ServerManager {
+    private customerFacingErrorBuilder;
     private serverRequestHandler;
     private settingsManager;
     private ucDataStore;
     private ucManager;
     protected runtime: Hono;
-    constructor(serverRequestHandler: ServerRequestHandler, settingsManager: SettingsManager<S>, ucDataStore: UCDataStore, ucManager: UCManager);
+    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder, serverRequestHandler: ServerRequestHandler, settingsManager: SettingsManager<S>, ucDataStore: UCDataStore, ucManager: UCManager);
     s(): SyncEdgeWorkerHonoServerManagerSettings;
     getRuntime(): Hono;
     overrideUCManager(ucManager: UCManager): void;

package/dist/esm/target/edge-worker-hono-server/SyncEdgeWorkerHonoServerManager.js

@@ -12,15 +12,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'inversify';
 import { NotAvailableError, NotCallableError } from '../../error/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
 let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
+    customerFacingErrorBuilder;
     serverRequestHandler;
     settingsManager;
     ucDataStore;
     ucManager;
     runtime;
-    constructor(serverRequestHandler, settingsManager, ucDataStore, ucManager) {
+    constructor(customerFacingErrorBuilder, serverRequestHandler, settingsManager, ucDataStore, ucManager) {
+        this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.serverRequestHandler = serverRequestHandler;
         this.settingsManager = settingsManager;
         this.ucDataStore = ucDataStore;
@@ -41,7 +44,7 @@ let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
         throw new NotCallableError('init', 'initSync', 'sync-only');
     }
     initSync() {
-        this.runtime = init();
+        this.runtime = init(this.customerFacingErrorBuilder);
     }
     async mount(_appManifest, _ucd, _contract) {
         throw new NotCallableError('mount', 'mountSync', 'sync-only');
@@ -78,10 +81,12 @@ let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
 };
 SyncEdgeWorkerHonoServerManager = __decorate([
     injectable(),
-    __param(0, inject(ServerRequestHandler)),
-    __param(1, inject('SettingsManager')),
-    __param(2, inject('UCDataStore')),
-    __param(3, inject('UCManager')),
-    __metadata("design:paramtypes", [ServerRequestHandler, Object, Object, Object])
+    __param(0, inject(CustomerFacingErrorBuilder)),
+    __param(1, inject(ServerRequestHandler)),
+    __param(2, inject('SettingsManager')),
+    __param(3, inject('UCDataStore')),
+    __param(4, inject('UCManager')),
+    __metadata("design:paramtypes", [CustomerFacingErrorBuilder,
+        ServerRequestHandler, Object, Object, Object])
 ], SyncEdgeWorkerHonoServerManager);
 export { SyncEdgeWorkerHonoServerManager };

package/dist/esm/target/index.d.ts

@@ -0,0 +1 @@
+export { TARGETS, type TargetName } from './lib/manifest.js';

package/dist/esm/target/index.js

@@ -0,0 +1 @@
+export { TARGETS } from './lib/manifest.js';

package/dist/esm/target/lib/cli/CLIManager.d.ts

@@ -1,5 +1,5 @@
-import type { AppUCsLoaderInput } from '../../../app/index.js';
-export type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'>;
+import type { TargetEntrypointInput } from '../entrypoint.js';
+export type Input = TargetEntrypointInput;
 export type Output = void;
 export interface CLIManager {
     handleCommand(input: Input): Promise<void>;

package/dist/esm/target/lib/client/consts.js

@@ -1,9 +1,10 @@
+import { unsafeDefaultSetting } from '../../../std/index.js';
 /**
  * @see TARGET_DEFAULT_SERVER_MANAGER_SETTINGS
  */
 export const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS = {
     server_cookies_name_auth: 'auth',
-    server_public_api_key: 'PublicApiKeyToBeChangedWhenDeploying',
+    server_public_api_key: unsafeDefaultSetting(),
     server_public_api_key_header_name: 'X-API-Key',
     server_public_url: 'http://localhost:7443',
 };

package/dist/esm/target/lib/entrypoint.d.ts

@@ -0,0 +1,2 @@
+import type { ProductUCsLoaderInput } from '../../product/index.js';
+export type TargetEntrypointInput = Pick<ProductUCsLoaderInput, 'appsRootPath' | 'from' | 'srcImporter'>;

package/dist/esm/target/lib/entrypoint.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/target/lib/manifest.d.ts

@@ -0,0 +1,13 @@
+import type { EnumOf } from '../../utils/index.js';
+export declare const TARGETS: {
+    readonly 'edge-worker-hono-server': "edge-worker-hono-server";
+    readonly 'nextjs-server': "nextjs-server";
+    readonly 'node-core-cli': "node-core-cli";
+    readonly 'node-express-server': "node-express-server";
+    readonly 'node-hono-server': "node-hono-server";
+    readonly 'node-mcp-server': "node-mcp-server";
+    readonly 'node-stricli-cli': "node-stricli-cli";
+    readonly 'react-native-pure': "react-native-pure";
+    readonly 'react-web-pure': "react-web-pure";
+};
+export type TargetName = EnumOf<typeof TARGETS>;

package/dist/esm/target/lib/manifest.js

@@ -0,0 +1,11 @@
+export const TARGETS = {
+    'edge-worker-hono-server': 'edge-worker-hono-server',
+    'nextjs-server': 'nextjs-server',
+    'node-core-cli': 'node-core-cli',
+    'node-express-server': 'node-express-server',
+    'node-hono-server': 'node-hono-server',
+    'node-mcp-server': 'node-mcp-server',
+    'node-stricli-cli': 'node-stricli-cli',
+    'react-native-pure': 'react-native-pure',
+    'react-web-pure': 'react-web-pure',
+};

package/dist/esm/target/lib/mcp-server/MCPServerBooter.d.ts

@@ -1,9 +1,9 @@
-import type { AppUCsLoaderInput } from '../../../app/index.js';
 import { ProductUCsLoader } from '../../../product/index.js';
 import type { I18nManager, Logger, Worker } from '../../../std/index.js';
 import { type UCManager } from '../../../uc/index.js';
+import type { TargetEntrypointInput } from '../entrypoint.js';
 import type { ServerManager } from '../server/ServerManager.js';
-type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'>;
+type Input = TargetEntrypointInput;
 export declare class MCPServerBooter implements Worker<Input, Promise<void>> {
     private i18nManager;
     private logger;

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

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import { CustomError, InternalServerError } from '../../../error/index.js';
+import { CustomError, IllegalArgumentError, InternalServerError, isInvalidJSON, } from '../../../error/index.js';
 let CustomerFacingErrorBuilder = class CustomerFacingErrorBuilder {
     environmentManager;
     logger;
@@ -26,6 +26,11 @@ let CustomerFacingErrorBuilder = class CustomerFacingErrorBuilder {
                 error,
             };
         }
+        if (isInvalidJSON(error)) {
+            return {
+                error: new IllegalArgumentError(),
+            };
+        }
         this.logger.error(error);
         // Create a specific generic error to avoid leaking potentially sensitive error
         // We all know the infamous "Cannot connect to MySQL database"...

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

@@ -1,11 +1,11 @@
-import type { AppUCsLoaderInput } from '../../../app/index.js';
 import { ProductUCsLoader } from '../../../product/index.js';
 import type { Configurable, EmailManager, FSManager, I18nManager, JobManager, Logger, SettingsManager, Worker } from '../../../std/index.js';
 import { type UCManager } from '../../../uc/index.js';
+import type { TargetEntrypointInput } from '../entrypoint.js';
 import { ServerInstaller } from './ServerInstaller.js';
 import type { ServerManager, ServerManagerSettings } from './ServerManager.js';
 type S = Pick<ServerManagerSettings, 'server_static_dir_path' | 'server_tmp_path'>;
-type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'> & {
+type Input = TargetEntrypointInput & {
     autoMountUCs?: boolean;
 };
 export declare class ServerBooter implements Configurable<S>, Worker<Input, Promise<void>> {

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

@@ -12,6 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 var ServerRequestHandler_1;
 import { inject, injectable } from 'inversify';
+import { IllegalArgumentError, isEmptyJSON } from '../../../error/index.js';
 import { UCBuilder, UCOutputReader, UCOutputSideEffectType, } from '../../../uc/index.js';
 import { AuthCookieCreator, } from './AuthCookieCreator.js';
 import { AuthenticationChecker } from './AuthenticationChecker.js';
@@ -119,8 +120,11 @@ let ServerRequestHandler = class ServerRequestHandler {
                 try {
                     uc.fill((await req.bodyFromJSON()));
                 }
-                catch (_err) {
-                    // Ignore any JSON.parse error as everything is validated afterwards
+                catch (err) {
+                    if (isEmptyJSON(err)) {
+                        break;
+                    }
+                    throw new IllegalArgumentError();
                 }
                 break;
             case 'query-params':

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

@@ -1,3 +1,4 @@
+import { unsafeDefaultSetting } from '../../../std/index.js';
 /**
  * @see TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS
  */
@@ -13,7 +14,7 @@ export const TARGET_DEFAULT_SERVER_MANAGER_SETTINGS = {
     server_csp_img_src: [],
     server_csp_script_src: [],
     server_private_api_key_entries: [],
-    server_public_api_key_entries: ['PublicApiKeyToBeChangedWhenDeploying'],
+    server_public_api_key_entries: [unsafeDefaultSetting()],
     server_public_api_key_header_name: 'X-API-Key',
     server_public_url: 'http://localhost:7443',
     server_ssl_fullchain_path: null,

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

@@ -4,12 +4,14 @@ 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 { CustomerFacingErrorBuilder } from '../server/CustomerFacingErrorBuilder.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 postInit(app: Express, customerFacingErrorBuilder: CustomerFacingErrorBuilder): 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

@@ -94,6 +94,12 @@ export function mountHandler(contract, express, handler) {
         express[httpMethod](pathAlias, handler);
     }
 }
+export function postInit(app, customerFacingErrorBuilder) {
+    app.use((err, _req, res, _next) => {
+        const { error } = customerFacingErrorBuilder.exec({ error: err });
+        return res.status(error.httpStatus).json(error.toObj());
+    });
+}
 export function toFile(f) {
     return {
         name: f.name,

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

@@ -2,9 +2,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 { CustomerFacingErrorBuilder } from '../server/CustomerFacingErrorBuilder.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 init<E extends Env = BlankEnv>(customerFacingErrorBuilder: CustomerFacingErrorBuilder): 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

@@ -86,13 +86,17 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
     };
     return handler;
 }
-export function init() {
+export function init(customerFacingErrorBuilder) {
     const app = new Hono();
     app.use(secureHeaders());
     app.use(logger());
     app.notFound((c) => {
-        const err = new NotFoundError();
-        return c.json(err.toObj(), err.httpStatus);
+        const error = new NotFoundError();
+        return c.json(error.toObj(), error.httpStatus);
+    });
+    app.onError((err, c) => {
+        const { error } = customerFacingErrorBuilder.exec({ error: err });
+        return c.json(error.toObj(), error.httpStatus);
     });
     return app;
 }

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

@@ -3,6 +3,7 @@ import type { AppManifest } from '../../app/index.js';
 import type { DirPath } from '../../dt/index.js';
 import type { Configurable, EnvironmentManager, Logger, LoggerSettings, SettingsManager } from '../../std/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
@@ -11,6 +12,7 @@ import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareB
 import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
 type S = ListenSettings & Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_tmp_path'> & StopSettings;
 export declare class NodeExpressServerManager implements Configurable<S>, ServerManager {
+    private customerFacingErrorBuilder;
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
     private helmetMB;
@@ -21,7 +23,7 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     private ucManager;
     protected runtime: Express;
     private server;
-    constructor(entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, helmetMB: HelmetMiddlewareBuilder, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, helmetMB: HelmetMiddlewareBuilder, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
     getRuntime(): Express;
     overrideUCManager(ucManager: UCManager): void;

package/dist/esm/target/node-express-server/NodeExpressServerManager.js

@@ -15,13 +15,15 @@ import https from 'node:https';
 import express, {} from 'express';
 import { inject, injectable } from 'inversify';
 import { NotCallableError } from '../../error/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { buildHandler, init, mountHandler, } from '../lib/server-express/funcs.js';
+import { buildHandler, init, mountHandler, postInit, } from '../lib/server-express/funcs.js';
 import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
 import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeExpressServerManager = class NodeExpressServerManager {
+    customerFacingErrorBuilder;
     entrypointsBuilder;
     environmentManager;
     helmetMB;
@@ -32,7 +34,8 @@ let NodeExpressServerManager = class NodeExpressServerManager {
     ucManager;
     runtime;
     server;
-    constructor(entrypointsBuilder, environmentManager, helmetMB, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+    constructor(customerFacingErrorBuilder, entrypointsBuilder, environmentManager, helmetMB, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
         this.helmetMB = helmetMB;
@@ -83,7 +86,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         await stop(this.server, this.settingsManager);
     }
     async warmUp() {
-        // Nothing to do
+        postInit(this.runtime, this.customerFacingErrorBuilder);
     }
     async createServer() {
         const port = this.s().server_binding_port;
@@ -102,15 +105,17 @@ let NodeExpressServerManager = class NodeExpressServerManager {
 };
 NodeExpressServerManager = __decorate([
     injectable(),
-    __param(0, inject(EntrypointsBuilder)),
-    __param(1, inject('EnvironmentManager')),
-    __param(2, inject(HelmetMiddlewareBuilder)),
-    __param(3, inject('Logger')),
-    __param(4, inject(ServerRequestHandler)),
-    __param(5, inject(ServerSSLCertLoader)),
-    __param(6, inject('SettingsManager')),
-    __param(7, inject('UCManager')),
-    __metadata("design:paramtypes", [EntrypointsBuilder, Object, HelmetMiddlewareBuilder, Object, ServerRequestHandler,
+    __param(0, inject(CustomerFacingErrorBuilder)),
+    __param(1, inject(EntrypointsBuilder)),
+    __param(2, inject('EnvironmentManager')),
+    __param(3, inject(HelmetMiddlewareBuilder)),
+    __param(4, inject('Logger')),
+    __param(5, inject(ServerRequestHandler)),
+    __param(6, inject(ServerSSLCertLoader)),
+    __param(7, inject('SettingsManager')),
+    __param(8, inject('UCManager')),
+    __metadata("design:paramtypes", [CustomerFacingErrorBuilder,
+        EntrypointsBuilder, Object, HelmetMiddlewareBuilder, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeExpressServerManager);
 export { NodeExpressServerManager };

package/dist/esm/target/node-hono-server/NodeHonoServerManager.d.ts

@@ -3,6 +3,7 @@ import type { AppManifest } from '../../app/index.js';
 import type { DirPath } from '../../dt/index.js';
 import type { Configurable, EnvironmentManager, Logger, SettingsManager } from '../../std/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
@@ -10,6 +11,7 @@ import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
 import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
 type S = ListenSettings & StopSettings;
 export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
+    private customerFacingErrorBuilder;
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
     private logger;
@@ -19,7 +21,7 @@ export declare class NodeHonoServerManager implements Configurable<S>, ServerMan
     private ucManager;
     protected runtime: Hono;
     private server;
-    constructor(entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
     getRuntime(): Hono;
     overrideUCManager(ucManager: UCManager): void;

package/dist/esm/target/node-hono-server/NodeHonoServerManager.js

@@ -16,12 +16,14 @@ import { createAdaptorServer } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
 import { inject, injectable } from 'inversify';
 import { NotCallableError } from '../../error/index.js';
+import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBuilder.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
 import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
 import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeHonoServerManager = class NodeHonoServerManager {
+    customerFacingErrorBuilder;
     entrypointsBuilder;
     environmentManager;
     logger;
@@ -31,7 +33,8 @@ let NodeHonoServerManager = class NodeHonoServerManager {
     ucManager;
     runtime;
     server;
-    constructor(entrypointsBuilder, environmentManager, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+    constructor(customerFacingErrorBuilder, entrypointsBuilder, environmentManager, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
         this.logger = logger;
@@ -57,7 +60,7 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = init();
+        this.runtime = init(this.customerFacingErrorBuilder);
         await this.createServer();
     }
     initSync() {
@@ -106,14 +109,16 @@ let NodeHonoServerManager = class NodeHonoServerManager {
 };
 NodeHonoServerManager = __decorate([
     injectable(),
-    __param(0, inject(EntrypointsBuilder)),
-    __param(1, inject('EnvironmentManager')),
-    __param(2, inject('Logger')),
-    __param(3, inject(ServerRequestHandler)),
-    __param(4, inject(ServerSSLCertLoader)),
-    __param(5, inject('SettingsManager')),
-    __param(6, inject('UCManager')),
-    __metadata("design:paramtypes", [EntrypointsBuilder, Object, Object, ServerRequestHandler,
+    __param(0, inject(CustomerFacingErrorBuilder)),
+    __param(1, inject(EntrypointsBuilder)),
+    __param(2, inject('EnvironmentManager')),
+    __param(3, inject('Logger')),
+    __param(4, inject(ServerRequestHandler)),
+    __param(5, inject(ServerSSLCertLoader)),
+    __param(6, inject('SettingsManager')),
+    __param(7, inject('UCManager')),
+    __metadata("design:paramtypes", [CustomerFacingErrorBuilder,
+        EntrypointsBuilder, Object, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeHonoServerManager);
 export { NodeHonoServerManager };

package/dist/esm/target/node-stricli-cli/NodeStricliCLIManager.d.ts

@@ -1,12 +1,14 @@
 import { WordingManager } from '../../i18n/index.js';
 import { type ProductManifest, 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 NodeStricliCLIManager implements CLIManager {
     private commandExecutor;
+    private i18nManager;
     private productManifest;
     private productUCsLoader;
     private wordingManager;
-    constructor(commandExecutor: CommandExecutor, productManifest: ProductManifest, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
+    constructor(commandExecutor: CommandExecutor, i18nManager: I18nManager, productManifest: ProductManifest, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
     handleCommand({ appsRootPath, srcImporter, }: Input): Promise<Output>;
 }

package/dist/esm/target/node-stricli-cli/NodeStricliCLIManager.js

@@ -18,16 +18,19 @@ import { ucifHint, ucifIsMandatory, ucifRepeatability, ucMountingPoint, } from '
 import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
 let NodeStricliCLIManager = class NodeStricliCLIManager {
     commandExecutor;
+    i18nManager;
     productManifest;
     productUCsLoader;
     wordingManager;
-    constructor(commandExecutor, productManifest, productUCsLoader, wordingManager) {
+    constructor(commandExecutor, i18nManager, productManifest, productUCsLoader, wordingManager) {
         this.commandExecutor = commandExecutor;
+        this.i18nManager = i18nManager;
         this.productManifest = productManifest;
         this.productUCsLoader = productUCsLoader;
         this.wordingManager = wordingManager;
     }
     async handleCommand({ appsRootPath, srcImporter, }) {
+        await this.i18nManager.init();
         const ucs = await this.productUCsLoader.exec({
             appsRootPath,
             srcImporter,
@@ -109,10 +112,11 @@ let NodeStricliCLIManager = class NodeStricliCLIManager {
 NodeStricliCLIManager = __decorate([
     injectable(),
     __param(0, inject(CommandExecutor)),
-    __param(1, inject('ProductManifest')),
-    __param(2, inject(ProductUCsLoader)),
-    __param(3, inject(WordingManager)),
-    __metadata("design:paramtypes", [CommandExecutor, Object, ProductUCsLoader,
+    __param(1, inject('I18nManager')),
+    __param(2, inject('ProductManifest')),
+    __param(3, inject(ProductUCsLoader)),
+    __param(4, inject(WordingManager)),
+    __metadata("design:paramtypes", [CommandExecutor, Object, Object, ProductUCsLoader,
         WordingManager])
 ], NodeStricliCLIManager);
 export { NodeStricliCLIManager };

package/dist/esm/testing/impl/NodeAppTesterConfigurator.d.ts

@@ -0,0 +1,15 @@
+import type { AppTesterConfigurator, AppTesterConfiguratorAuthSettersConfig, AppTesterConfiguratorInputFillers, AppTesterConfiguratorSideEffects, AppTesterConfiguratorSpecificAssertions } from '../AppTesterConfigurator.js';
+import type { AppTesterCtx } from '../ctx.js';
+import type { AppTesterFlow } from '../flow.js';
+export declare class NodeAppTesterConfigurator implements AppTesterConfigurator {
+    authSettersConfig(): Promise<AppTesterConfiguratorAuthSettersConfig | undefined>;
+    bindImplementations(ctx: AppTesterCtx): Promise<void>;
+    clearExecution(ctx: AppTesterCtx): Promise<void>;
+    flows(): Promise<AppTesterFlow[]>;
+    inputFillers(): Promise<AppTesterConfiguratorInputFillers | undefined>;
+    opts(): Promise<AppTesterCtx['opts']>;
+    seed(_ctx: AppTesterCtx): Promise<void>;
+    sideEffects(_ctx: AppTesterCtx): Promise<AppTesterConfiguratorSideEffects | undefined>;
+    specificAssertions(): Promise<AppTesterConfiguratorSpecificAssertions | undefined>;
+    updateSettings<S>(ctx: AppTesterCtx, settings: S): Promise<void>;
+}