libmodulor 0.27.0 → 0.29.0

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

@@ -4,8 +4,9 @@ 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';
+import type { CORSMiddlewareBuilder } from './CORSMiddlewareBuilder.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>(customerFacingErrorBuilder: CustomerFacingErrorBuilder): Hono<E>;
+export declare function init<E extends Env = BlankEnv>(corsMB: CORSMiddlewareBuilder, 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,9 +86,10 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
     };
     return handler;
 }
-export function init(customerFacingErrorBuilder) {
+export function init(corsMB, customerFacingErrorBuilder) {
     const app = new Hono();
     app.use(secureHeaders());
+    app.use(corsMB.exec({}));
     app.use(logger());
     app.notFound((c) => {
         const error = new NotFoundError();

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

@@ -1,2 +1,6 @@
+import type { SemVerVersion } from '../../dt/index.js';
+import type { HTTPHeaderName } from '../../utils/index.js';
 export type AuthCookieName = 'auth';
 export type PublicApiKeyHeaderName = 'X-API-Key' | (string & {});
+export declare const AUTHORIZATION_HEADER_NAME: HTTPHeaderName;
+export declare const DEFAULT_VERSION: SemVerVersion;

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

@@ -1 +1,2 @@
-export {};
+export const AUTHORIZATION_HEADER_NAME = 'Authorization';
+export const DEFAULT_VERSION = '0.1.0';

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

@@ -1,6 +1,7 @@
 import type { AppManifest } from '../../app/index.js';
-import type { DirPath } from '../../dt/index.js';
+import type { DirPath, URLPath } from '../../dt/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
+import type { OpenAPISpec } from '../lib/openapi/types.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 export declare class NextJSServerManager implements ServerManager {
     overrideUCManager(_ucManager: UCManager): void;
@@ -8,6 +9,7 @@ export declare class NextJSServerManager implements ServerManager {
     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;
+    mountOpenAPISpec(_spec: OpenAPISpec, _at: URLPath): Promise<void>;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

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

@@ -21,6 +21,9 @@ let NextJSServerManager = class NextJSServerManager {
     mountSync(_appManifest, _ucd, _contract) {
         // Nothing to do
     }
+    async mountOpenAPISpec(_spec, _at) {
+        // Nothing to do
+    }
     async mountStaticDir(_dirPath) {
         // Nothing to do
     }

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

@@ -41,7 +41,7 @@ let NodeCoreCLIManager = class NodeCoreCLIManager {
             uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc),
             uc,
         ]));
-        if (!command || !command.trim() || command === '--help') {
+        if (!command?.trim() || command === '--help') {
             showHelp(ucs, this.wordingManager);
         }
         else if (command === '--version') {

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

@@ -1,21 +1,24 @@
 import { type Express } from 'express';
 import type { AppManifest } from '../../app/index.js';
-import type { DirPath } from '../../dt/index.js';
+import type { DirPath, URLPath } 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 type { OpenAPISpec } from '../lib/openapi/types.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';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+import { CORSMiddlewareBuilder } from '../lib/server-express/CORSMiddlewareBuilder.js';
 import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
 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 corsMiddlewareBuilder;
     private customerFacingErrorBuilder;
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
-    private helmetMB;
+    private helmetMiddlewareBuilder;
     protected logger: Logger;
     private serverRequestHandler;
     private serverSSLCertLoader;
@@ -23,7 +26,7 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     private ucManager;
     protected runtime: Express;
     private server;
-    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, helmetMB: HelmetMiddlewareBuilder, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    constructor(corsMiddlewareBuilder: CORSMiddlewareBuilder, customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, helmetMiddlewareBuilder: HelmetMiddlewareBuilder, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
     getRuntime(): Express;
     overrideUCManager(ucManager: UCManager): void;
@@ -31,6 +34,7 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     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;
+    mountOpenAPISpec(spec: OpenAPISpec, at: URLPath): Promise<void>;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

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

@@ -19,14 +19,16 @@ import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBui
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+import { CORSMiddlewareBuilder } from '../lib/server-express/CORSMiddlewareBuilder.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 {
+    corsMiddlewareBuilder;
     customerFacingErrorBuilder;
     entrypointsBuilder;
     environmentManager;
-    helmetMB;
+    helmetMiddlewareBuilder;
     logger;
     serverRequestHandler;
     serverSSLCertLoader;
@@ -34,11 +36,12 @@ let NodeExpressServerManager = class NodeExpressServerManager {
     ucManager;
     runtime;
     server;
-    constructor(customerFacingErrorBuilder, entrypointsBuilder, environmentManager, helmetMB, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+    constructor(corsMiddlewareBuilder, customerFacingErrorBuilder, entrypointsBuilder, environmentManager, helmetMiddlewareBuilder, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.corsMiddlewareBuilder = corsMiddlewareBuilder;
         this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
-        this.helmetMB = helmetMB;
+        this.helmetMiddlewareBuilder = helmetMiddlewareBuilder;
         this.logger = logger;
         this.serverRequestHandler = serverRequestHandler;
         this.serverSSLCertLoader = serverSSLCertLoader;
@@ -64,7 +67,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = init(this.helmetMB, this.s().logger_level, this.s().server_tmp_path);
+        this.runtime = init(this.corsMiddlewareBuilder, this.helmetMiddlewareBuilder, this.s().logger_level, this.s().server_tmp_path);
         await this.createServer();
     }
     initSync() {
@@ -76,6 +79,11 @@ let NodeExpressServerManager = class NodeExpressServerManager {
     mountSync(appManifest, ucd, contract) {
         this.mountCommon(appManifest, ucd, contract);
     }
+    async mountOpenAPISpec(spec, at) {
+        this.runtime.get(at, (_req, res) => {
+            res.send(spec);
+        });
+    }
     async mountStaticDir(dirPath) {
         this.runtime.use(express.static(dirPath));
     }
@@ -105,16 +113,18 @@ let NodeExpressServerManager = class NodeExpressServerManager {
 };
 NodeExpressServerManager = __decorate([
     injectable(),
-    __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,
+    __param(0, inject(CORSMiddlewareBuilder)),
+    __param(1, inject(CustomerFacingErrorBuilder)),
+    __param(2, inject(EntrypointsBuilder)),
+    __param(3, inject('EnvironmentManager')),
+    __param(4, inject(HelmetMiddlewareBuilder)),
+    __param(5, inject('Logger')),
+    __param(6, inject(ServerRequestHandler)),
+    __param(7, inject(ServerSSLCertLoader)),
+    __param(8, inject('SettingsManager')),
+    __param(9, inject('UCManager')),
+    __metadata("design:paramtypes", [CORSMiddlewareBuilder,
+        CustomerFacingErrorBuilder,
         EntrypointsBuilder, Object, HelmetMiddlewareBuilder, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeExpressServerManager);

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

@@ -1,16 +1,19 @@
 import type { Hono } from 'hono';
 import type { AppManifest } from '../../app/index.js';
-import type { DirPath } from '../../dt/index.js';
+import type { DirPath, URLPath } 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 type { OpenAPISpec } from '../lib/openapi/types.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';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+import { CORSMiddlewareBuilder } from '../lib/server-hono/CORSMiddlewareBuilder.js';
 import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
 type S = ListenSettings & StopSettings;
 export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
+    private corsMiddlewareBuilder;
     private customerFacingErrorBuilder;
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
@@ -21,7 +24,7 @@ export declare class NodeHonoServerManager implements Configurable<S>, ServerMan
     private ucManager;
     protected runtime: Hono;
     private server;
-    constructor(customerFacingErrorBuilder: CustomerFacingErrorBuilder, entrypointsBuilder: EntrypointsBuilder, environmentManager: EnvironmentManager, logger: Logger, serverRequestHandler: ServerRequestHandler, serverSSLCertLoader: ServerSSLCertLoader, settingsManager: SettingsManager<S>, ucManager: UCManager);
+    constructor(corsMiddlewareBuilder: CORSMiddlewareBuilder, 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;
@@ -29,6 +32,7 @@ export declare class NodeHonoServerManager implements Configurable<S>, ServerMan
     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;
+    mountOpenAPISpec(spec: OpenAPISpec, at: URLPath): Promise<void>;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

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

@@ -20,9 +20,11 @@ import { CustomerFacingErrorBuilder } from '../lib/server/CustomerFacingErrorBui
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
+import { CORSMiddlewareBuilder } from '../lib/server-hono/CORSMiddlewareBuilder.js';
 import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
 import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeHonoServerManager = class NodeHonoServerManager {
+    corsMiddlewareBuilder;
     customerFacingErrorBuilder;
     entrypointsBuilder;
     environmentManager;
@@ -33,7 +35,8 @@ let NodeHonoServerManager = class NodeHonoServerManager {
     ucManager;
     runtime;
     server;
-    constructor(customerFacingErrorBuilder, entrypointsBuilder, environmentManager, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+    constructor(corsMiddlewareBuilder, customerFacingErrorBuilder, entrypointsBuilder, environmentManager, logger, serverRequestHandler, serverSSLCertLoader, settingsManager, ucManager) {
+        this.corsMiddlewareBuilder = corsMiddlewareBuilder;
         this.customerFacingErrorBuilder = customerFacingErrorBuilder;
         this.entrypointsBuilder = entrypointsBuilder;
         this.environmentManager = environmentManager;
@@ -60,7 +63,7 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = init(this.customerFacingErrorBuilder);
+        this.runtime = init(this.corsMiddlewareBuilder, this.customerFacingErrorBuilder);
         await this.createServer();
     }
     initSync() {
@@ -72,6 +75,11 @@ let NodeHonoServerManager = class NodeHonoServerManager {
     mountSync(appManifest, ucd, contract) {
         this.mountCommon(appManifest, ucd, contract);
     }
+    async mountOpenAPISpec(spec, at) {
+        this.runtime.get(at, (c) => {
+            return c.json(spec);
+        });
+    }
     async mountStaticDir(dirPath) {
         this.runtime.use(serveStatic({ root: dirPath }));
     }
@@ -109,15 +117,17 @@ let NodeHonoServerManager = class NodeHonoServerManager {
 };
 NodeHonoServerManager = __decorate([
     injectable(),
-    __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,
+    __param(0, inject(CORSMiddlewareBuilder)),
+    __param(1, inject(CustomerFacingErrorBuilder)),
+    __param(2, inject(EntrypointsBuilder)),
+    __param(3, inject('EnvironmentManager')),
+    __param(4, inject('Logger')),
+    __param(5, inject(ServerRequestHandler)),
+    __param(6, inject(ServerSSLCertLoader)),
+    __param(7, inject('SettingsManager')),
+    __param(8, inject('UCManager')),
+    __metadata("design:paramtypes", [CORSMiddlewareBuilder,
+        CustomerFacingErrorBuilder,
         EntrypointsBuilder, Object, Object, ServerRequestHandler,
         ServerSSLCertLoader, Object, Object])
 ], NodeHonoServerManager);

package/dist/esm/target/node-mcp-server/NodeLocalStdioMCPServerManager.d.ts

@@ -1,10 +1,11 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { AppManifest } from '../../app/index.js';
-import type { DirPath } from '../../dt/index.js';
+import type { DirPath, URLPath } from '../../dt/index.js';
 import { WordingManager } from '../../i18n/index.js';
 import type { ProductManifest } from '../../product/index.js';
 import type { Configurable, LoggerSettings, SettingsManager } from '../../std/index.js';
 import { UCBuilder, type UCDef, type UCHTTPContract, type UCInput, type UCManager, type UCOPIBase } from '../../uc/index.js';
+import type { OpenAPISpec } from '../lib/openapi/types.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 type S = Pick<LoggerSettings, 'logger_level'>;
 /**
@@ -34,6 +35,7 @@ export declare class NodeLocalStdioMCPServerManager implements Configurable<S>,
     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;
+    mountOpenAPISpec(_spec: OpenAPISpec, _at: URLPath): Promise<void>;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/esm/target/node-mcp-server/NodeLocalStdioMCPServerManager.js

@@ -17,6 +17,7 @@ import { inject, injectable } from 'inversify';
 import { NotAvailableError } from '../../error/index.js';
 import { WordingManager } from '../../i18n/index.js';
 import { UCBuilder, ucifIsMandatory, ucMountingPoint, } from '../../uc/index.js';
+import { DEFAULT_VERSION } from '../lib/shared.js';
 import { propertyType, resError, resObj } from './funcs.js';
 /**
  * A simple MCP Server implementation
@@ -67,6 +68,9 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
     mountSync(appManifest, ucd, contract) {
         this.mountCommon(appManifest, ucd, contract);
     }
+    async mountOpenAPISpec(_spec, _at) {
+        // Nothing to do
+    }
     async mountStaticDir(_dirPath) {
         throw new NotAvailableError('mountStaticDir');
     }
@@ -90,18 +94,18 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
         const res = {
             type: 'object',
         };
-        if (uc.inputFields.length > 0) {
-            const properties = {};
-            for (const f of uc.inputFields) {
-                const { def, key } = f;
-                const { desc } = this.wordingManager.ucif(f);
-                properties[key] = {
-                    ...propertyType(def),
-                    description: desc,
-                    required: ucifIsMandatory(def),
-                };
-            }
-            res.properties = properties;
+        if (!uc.hasInput()) {
+            return res;
+        }
+        res.properties = {};
+        for (const f of uc.inputFields) {
+            const { def, key } = f;
+            const { desc } = this.wordingManager.ucif(f);
+            res.properties[key] = {
+                ...propertyType(def),
+                description: desc,
+                required: ucifIsMandatory(def),
+            };
         }
         return res;
     }
@@ -140,9 +144,10 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
         }
     }
     initCommon() {
+        const { name, version } = this.productManifest;
         this.runtime = new Server({
-            name: this.productManifest.name,
-            version: '0.1.0',
+            name: name,
+            version: version ?? DEFAULT_VERSION,
         }, {
             capabilities: {
                 tools: {},

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

@@ -12,8 +12,4 @@ export type PropertyArrayType<T extends PropertyPrimitiveType> = {
 export type PropertyType<T extends PropertyPrimitiveType = PropertyPrimitiveType> = {
     type: T;
 } | PropertyArrayType<T>;
-export type Property<T extends PropertyPrimitiveType = PropertyPrimitiveType> = PropertyType<T> & {
-    description: string | null;
-    required: boolean;
-};
 export type Tool = ListToolsResult['tools'][0];

package/dist/esm/target/react-web-pure/UCForm.d.ts

@@ -1,4 +1,4 @@
 import { type ReactElement } from 'react';
-import type { UCInput, UCOPIBase } from '../../uc/index.js';
+import { type UCInput, type UCOPIBase } from '../../uc/index.js';
 import type { UCFormProps } from '../lib/react/form.js';
 export declare function UCForm<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ clearAfterExec, disabled, execState, onSubmit: onSubmitBase, uc, }: UCFormProps<I, OPI0, OPI1>): ReactElement;

package/dist/esm/target/react-web-pure/UCForm.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef } from 'react';
+import { UCExecRes } from '../../uc/index.js';
 import { useStyleContext } from '../lib/react/StyleContextProvider.js';
 import { UCFormField } from './UCFormField.js';
 import { UCFormSubmitControl } from './UCFormSubmitControl.js';
@@ -8,8 +9,8 @@ export function UCForm({ clearAfterExec, disabled, execState, onSubmit: onSubmit
     const formRef = useRef(null);
     const onSubmit = async (e) => {
         e.preventDefault();
-        const succeeded = await onSubmitBase();
-        if (succeeded && clearAfterExec) {
+        const res = await onSubmitBase();
+        if (res === UCExecRes.SUCCEEDED && clearAfterExec) {
             formRef.current?.reset();
         }
     };

package/dist/esm/testing/workers/checkers/AppI18nChecker.js

@@ -16,7 +16,7 @@ const ERR_I18N_LABEL_NO_DOT = (key) => `The i18n key '${key}' is a label, thus i
 const ERR_I18N_MISSING_TRANS = (key, lang) => `The i18n key '${key}' is missing for lang '${lang}'`;
 let AppI18nChecker = class AppI18nChecker {
     static { AppI18nChecker_1 = this; }
-    static I18N_KEY_PATTERN = /(dt_([A-Z][A-Za-z0-9]+)_([A-Za-z0-9]+)_(desc|label))|(err_([A-Za-z_]+))|(uc_([A-Z][A-Za-z0-9]+)_(client_confirm_(cancel|confirm|message|title)|desc|label|i_submit_(changing|idle|initializing|submitting)|op_(0|1)_(empty|label)))|(ucif_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(ucof_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(validation_([a-z]+)_([A-Z][A-Za-z0-9]+))/;
+    static I18N_KEY_PATTERN = /(dt_([A-Z][A-Za-z0-9]+)_constr_format)|(dt_([A-Z][A-Za-z0-9]+)_([A-Za-z0-9]+)_(desc|label))|(err_([A-Za-z_]+))|(uc_([A-Z][A-Za-z0-9]+)_(client_confirm_(cancel|confirm|message|title)|desc|label|i_submit_(changing|idle|initializing|submitting)|op_(0|1)_(empty|label)))|(ucif_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(ucof_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(validation_([a-z]+)_([A-Z][A-Za-z0-9]+))/;
     output;
     constructor() {
         this.output = { errors: [] };
@@ -41,7 +41,9 @@ let AppI18nChecker = class AppI18nChecker {
                 if (!matches) {
                     this.output.errors.push(ERR_I18N_KEY_INVALID(key));
                 }
-                if (key.endsWith('_label') && translation.endsWith('.')) {
+                if (key.endsWith('_label') &&
+                    translation.endsWith('.') &&
+                    !translation.endsWith('...')) {
                     this.output.errors.push(ERR_I18N_LABEL_NO_DOT(key));
                 }
             }

package/dist/esm/uc/UC.d.ts

@@ -21,6 +21,7 @@ export declare class UC<I extends UCInput | undefined = undefined, OPI0 extends
     clear(): void;
     clearSensitiveInputFields(): void;
     fill(input: UCInputPartial<I>): this;
+    hasInput(): boolean;
     hasInputField(key: UCFieldKey): boolean;
     hasMediaInInput(): boolean;
     hasOutputParts(): boolean;
@@ -29,6 +30,7 @@ export declare class UC<I extends UCInput | undefined = undefined, OPI0 extends
     inputFieldsOrdered(): UCInputField<any>[];
     inputFieldsInsensitive(): UCInputField<any>[];
     inputFieldsSensitive(): UCInputField<any>[];
+    inputFieldsRepeatable(): UCInputField<any>[];
     needsInputFilling(): boolean;
     needsOutputDisplay(): boolean;
     operatesOnAggregate(): boolean;

package/dist/esm/uc/UC.js

@@ -1,6 +1,6 @@
 import { TFile, Validation } from '../dt/index.js';
 import { isBlank } from '../utils/index.js';
-import { ucifIsMandatory, ucifIsSensitive, ucifMustBeFilledManually, } from './input-field.js';
+import { ucifIsMandatory, ucifIsSensitive, ucifMustBeFilledManually, ucifRepeatability, } from './input-field.js';
 import { AggregateInputDef } from './io/input/AggregateInput.js';
 import { ListInputDef } from './io/input/ListInput.js';
 import { UCInputField } from './UCInputField.js';
@@ -44,6 +44,9 @@ export class UC {
         }
         return this;
     }
+    hasInput() {
+        return this.inputFields.length > 0;
+    }
     hasInputField(key) {
         return this.inputFields.find((f) => f.key === key) !== undefined;
     }
@@ -104,6 +107,18 @@ export class UC {
     inputFieldsSensitive() {
         return this.inputFields.filter((f) => ucifIsSensitive(f.def));
     }
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
+    inputFieldsRepeatable() {
+        const res = [];
+        for (const f of this.inputFields) {
+            const [isRepeatable] = ucifRepeatability(f.def);
+            if (!isRepeatable) {
+                continue;
+            }
+            res.push(f);
+        }
+        return res;
+    }
     needsInputFilling() {
         const fields = this.inputFields;
         if (fields.length === 0) {

package/dist/esm/uc/data-store.d.ts

@@ -1,11 +1,18 @@
 import type { AppName } from '../app/index.js';
 import type { UIntQuantity, UUID } from '../dt/index.js';
-import type { Clearable, Initializable, StringKeys } from '../utils/index.js';
+import type { Clearable, EnumOf, Initializable, StringKeys } from '../utils/index.js';
 import type { UCData } from './data.js';
 import type { UCExecMode } from './exec.js';
 import type { UCInput } from './input.js';
 import type { UCName } from './metadata.js';
 export type UCDataStoreDatasetName = string;
+export declare const UCDataStoreMode: {
+    readonly NONE: "NONE";
+    readonly READ: "READ";
+    readonly READ_WRITE: "READ_WRITE";
+    readonly WRITE: "WRITE";
+};
+export type UCDataStoreMode = EnumOf<typeof UCDataStoreMode>;
 interface UCDataStoreQueryOpts {
 }
 export type UCDataStoreReadFilter<T> = T | T[];
@@ -67,4 +74,5 @@ export interface UCDataStore extends Clearable, Initializable {
     writeBulk<I extends UCInput | undefined = undefined, D extends UCData | null = null>(records: UCDataStoreRecord<I, D>[], opts?: UCDataStoreWriteOpts): Promise<void>;
     writeProjection<T extends object>(name: string, data: T, opts?: UCDataStoreWriteProjectionOpts): Promise<void>;
 }
+export declare function assertCan(op: 'read' | 'write', mode: UCDataStoreMode): void;
 export {};

package/dist/esm/uc/data-store.js

@@ -1 +1,33 @@
-export {};
+import { UnavailableError } from '../error/index.js';
+export const UCDataStoreMode = {
+    NONE: 'NONE',
+    READ: 'READ',
+    READ_WRITE: 'READ_WRITE',
+    WRITE: 'WRITE',
+};
+export function assertCan(op, mode) {
+    switch (mode) {
+        case 'NONE':
+            if (op === 'read') {
+                throw new UnavailableError('err_uc_data_store_not_readable');
+            }
+            if (op === 'write') {
+                throw new UnavailableError('err_uc_data_store_not_writable');
+            }
+            break;
+        case 'READ':
+            if (op === 'write') {
+                throw new UnavailableError('err_uc_data_store_not_writable');
+            }
+            break;
+        case 'READ_WRITE':
+            break;
+        case 'WRITE':
+            if (op === 'read') {
+                throw new UnavailableError('err_uc_data_store_not_readable');
+            }
+            break;
+        default:
+            mode;
+    }
+}

package/dist/esm/uc/impl/CloudflareD1UCDataStore.d.ts

@@ -1,10 +1,10 @@
 import type { D1Database } from '@cloudflare/workers-types';
 import type { Configurable, SettingsManager } from '../../std/index.js';
 import type { UCData } from '../data.js';
-import type { UCDataStore, UCDataStoreReadOpts, UCDataStoreReadProjectionOpts, UCDataStoreReadResponse, UCDataStoreRecord, UCDataStoreTx, UCDataStoreWriteOpts, UCDataStoreWriteProjectionOpts, UCDataStoreWriteProjectionSpecificBinding } from '../data-store.js';
+import { type UCDataStore, type UCDataStoreReadOpts, type UCDataStoreReadProjectionOpts, type UCDataStoreReadResponse, type UCDataStoreRecord, type UCDataStoreTx, type UCDataStoreWriteOpts, type UCDataStoreWriteProjectionOpts, type UCDataStoreWriteProjectionSpecificBinding } from '../data-store.js';
 import type { UCInput } from '../input.js';
 import type { UCSettings } from '../settings.js';
-type S = Pick<UCSettings, 'uc_data_store_ucs_dataset_name'>;
+type S = Pick<UCSettings, 'uc_data_store_mode' | 'uc_data_store_ucs_dataset_name'>;
 export declare const ROW_COLS: (keyof UCDataStoreRecord)[];
 /**
  * @alpha This implementation is still a WIP and needs improvement

package/dist/esm/uc/impl/CloudflareD1UCDataStore.js

@@ -12,6 +12,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'inversify';
 import { NotAvailableError, NotImplementedError } from '../../error/index.js';
+import { assertCan, } from '../data-store.js';
 export const ROW_COLS = [
     'aggregateId',
     'appName',
@@ -38,6 +39,7 @@ let CloudflareD1UCDataStore = class CloudflareD1UCDataStore {
     }
     s() {
         return {
+            uc_data_store_mode: this.settingsManager.get()('uc_data_store_mode'),
             uc_data_store_ucs_dataset_name: this.settingsManager.get()('uc_data_store_ucs_dataset_name'),
         };
     }
@@ -92,6 +94,7 @@ CREATE INDEX IF NOT EXISTS uc_executions_user_id_index ON uc_executions (userId)
     }
     async read(opts) {
         this.assertClient();
+        assertCan('read', this.s().uc_data_store_mode);
         // TODO : Consider using a query builder (or Google's pipe operator ?) when it gets too complicated or dangerous
         const query = [
             `select * from ${this.s().uc_data_store_ucs_dataset_name}`,
@@ -131,6 +134,7 @@ CREATE INDEX IF NOT EXISTS uc_executions_user_id_index ON uc_executions (userId)
         };
     }
     async readProjection(_name, _opts) {
+        assertCan('read', this.s().uc_data_store_mode);
         throw new NotImplementedError('readProjection');
     }
     async startTx() {
@@ -144,6 +148,7 @@ CREATE INDEX IF NOT EXISTS uc_executions_user_id_index ON uc_executions (userId)
     }
     async write(record, _opts) {
         this.assertClient();
+        assertCan('write', this.s().uc_data_store_mode);
         const cols = ROW_COLS.join(', ');
         const placeholders = ROW_COLS.map(() => '?').join(', ');
         // Use variables only for variables declared here => never for data coming from outside this method !
@@ -166,9 +171,11 @@ CREATE INDEX IF NOT EXISTS uc_executions_user_id_index ON uc_executions (userId)
             .run();
     }
     async writeBulk(_records, _opts) {
+        assertCan('write', this.s().uc_data_store_mode);
         throw new NotImplementedError('writeBulk');
     }
     async writeProjection(_name, _data, _opts) {
+        assertCan('write', this.s().uc_data_store_mode);
         throw new NotImplementedError('writeProjection');
     }
     setClient(client) {