libmodulor 0.3.0 → 0.5.0

package/dist/esm/target/lib/react/useUC.js

@@ -1,5 +1,13 @@
 import { useState } from 'react';
 import { UC, } from '../../../uc/index.js';
+/**
+ * This hook provides utilities to init a use case and perform actions on it in a React way
+ * @param appManifest
+ * @param def
+ * @param auth
+ * @param opts
+ * @returns
+ */
 export function useUC(appManifest, def, auth, opts) {
     const [uc, setUC] = useState(() => {
         const { name: appName, ucReg } = appManifest;
@@ -13,8 +21,22 @@ export function useUC(appManifest, def, auth, opts) {
         }
         return v;
     });
+    /**
+     * Get a new `UC` based on the initial one
+     * @param i
+     * @returns
+     */
     const clone = (i) => new UC(uc.appManifest, uc.def, uc.auth).fill(i);
+    /**
+     * Get a new `UC` based on the "common" settings of the initial one (i.e. `auth`)
+     * @param ucd
+     * @returns
+     */
     const divert = (siblingUCD) => new UC(uc.appManifest, siblingUCD, uc.auth);
+    /**
+     * Update the existing `uc` in an immutable way to trigger components re-rendering
+     * @param i
+     */
     const refill = (i) => {
         setUC(new UC(uc.appManifest, uc.def, uc.auth).fill(i));
     };

package/dist/esm/target/lib/react/useUCOR.d.ts

@@ -2,6 +2,21 @@ import type { UCInput, UCOPIBase, UCOutputReader, UCOutputReaderPart } from '../
 type AppendFunc<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (ucor: UCOutputReader<any, OPI0, OPI1>) => void;
 type RemoveFunc<OPI extends UCOPIBase> = (item: OPI) => void;
 type UpdateFunc<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (ucor: UCOutputReader<any, OPI0, OPI1>) => void;
+/**
+ * This hook provides utilities to act on a {@link UCOutputReader} in a React way
+ *
+ * A usual scenario of this is a "CRUD-like" UI displaying multiple use cases :
+ *
+ *   - A `List` use case to display a collection of items
+ *   - A `Create` use case to add an item
+ *   - A `Delete` use case to remove an item
+ *   - An `Update` use case to update an item
+ *
+ * Whenever one of this use case is performed, you can use the `ucor` to act on the main UCOR in an immutable way.
+ *
+ * @param ucor
+ * @returns
+ */
 export declare function useUCOR<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucor: UCOutputReader<I, OPI0, OPI1>): [
     UCOutputReaderPart<NonNullable<OPI0>> | undefined,
     UCOutputReaderPart<NonNullable<OPI1>> | undefined,

package/dist/esm/target/lib/react/useUCOR.js

@@ -39,10 +39,35 @@ function update(a, b) {
         items: newItems,
     };
 }
+/**
+ * This hook provides utilities to act on a {@link UCOutputReader} in a React way
+ *
+ * A usual scenario of this is a "CRUD-like" UI displaying multiple use cases :
+ *
+ *   - A `List` use case to display a collection of items
+ *   - A `Create` use case to add an item
+ *   - A `Delete` use case to remove an item
+ *   - An `Update` use case to update an item
+ *
+ * Whenever one of this use case is performed, you can use the `ucor` to act on the main UCOR in an immutable way.
+ *
+ * @param ucor
+ * @returns
+ */
 export function useUCOR(ucor) {
     const [part0, setPart0] = useState(ucor.part0());
     const [part1, setPart1] = useState(ucor.part1());
+    /**
+     * Append items to part0
+     * @param ucor2
+     * @returns
+     */
     const append0 = (ucor2) => setPart0((prev) => append(prev, ucor2.part0()));
+    /**
+     * Append items to part1 (if applicable)
+     * @param ucor2
+     * @returns
+     */
     const append1 = (ucor2) => setPart1((prev) => {
         const b = ucor2.part1();
         if (!prev || !b) {
@@ -50,14 +75,34 @@ export function useUCOR(ucor) {
         }
         return append(prev, b);
     });
+    /**
+     * Remove the item from part0
+     * @param item
+     * @returns
+     */
     const remove0 = (item) => setPart0((prev) => remove(prev, item));
+    /**
+     * Remove the item from part1 (if applicable)
+     * @param item
+     * @returns
+     */
     const remove1 = (item) => setPart1((prev) => {
         if (!prev) {
             return;
         }
         return remove(prev, item);
     });
+    /**
+     * Update items in part0
+     * @param ucor2
+     * @returns
+     */
     const update0 = (ucor2) => setPart0((prev) => update(prev, ucor2.part0()));
+    /**
+     * Update items in part1 (if applicable)
+     * @param ucor2
+     * @returns
+     */
     const update1 = (ucor2) => setPart1((prev) => {
         const b = ucor2.part1();
         if (!prev || !b) {

package/dist/esm/target/lib/rn/input.d.ts

@@ -0,0 +1,15 @@
+import type { TextInputProps } from 'react-native';
+import { type DataType, type ErrorMessage } from '../../../dt/index.js';
+import { type UCExecState, type UCInputField } from '../../../uc/index.js';
+export interface RNInputDef {
+    internal?: undefined;
+    /**
+     * Fields that are part of {@link TextInputProps}
+     *
+     * These are safe to destructure directly in a `<TextInput />` component.
+     *
+     * @example `<TextInput {...attrs.spec} />`
+     */
+    spec?: TextInputProps;
+}
+export declare function rnInputDef<T extends DataType>(field: UCInputField<T>, execState: UCExecState, _errMsg: ErrorMessage | null): RNInputDef;

package/dist/esm/target/lib/rn/input.js

@@ -0,0 +1,28 @@
+import { TString, } from '../../../dt/index.js';
+import { ucIsDisabled, ucifHint, ucifId, } from '../../../uc/index.js';
+export function rnInputDef(field, execState, _errMsg) {
+    const def = {
+        internal: undefined,
+        spec: {},
+    };
+    if (!def.spec) {
+        // Just a guard to safely type the rest of the function without using !
+        return def;
+    }
+    const { key, def: fDef } = field;
+    const { type: fType } = fDef;
+    def.spec.editable = !ucIsDisabled(execState);
+    def.spec.id = ucifId(key);
+    // Testing the types by usage probability to make the if/else evaluation stop ideally earlier
+    if (fType instanceof TString) {
+        const constraints = fType.getConstraints();
+        if (constraints) {
+            def.spec.maxLength = constraints.maxLength;
+        }
+        def.spec.multiline = fType.isPotentiallyLong();
+    }
+    def.spec.placeholder = ucifHint(fDef);
+    def.spec.inputMode = fType.rnInputMode();
+    def.spec.secureTextEntry = fType.isSensitive();
+    return def;
+}

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

@@ -35,7 +35,7 @@ let AuthenticationChecker = class AuthenticationChecker {
             authorizationHeader,
         });
         const output = {
-            allowed: false,
+            allowed: false, // By default it's not allowed
             auth: null,
         };
         const { lifecycle: { server }, sec, } = uc.def;
@@ -52,6 +52,7 @@ let AuthenticationChecker = class AuthenticationChecker {
             output.allowed = allowed;
         }
         else {
+            // Follows the OpenAPI spec : https://swagger.io/docs/specification/authentication
             switch (authType) {
                 case 'apiKey':
                     if (authorizationHeader &&

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

@@ -46,6 +46,7 @@ let BasicAuthenticationChecker = class BasicAuthenticationChecker {
         if (!passwordsMatch) {
             return null;
         }
+        // TODO : Improve this by fetching data from a data store for example
         return {
             organization: {
                 id: '',

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

@@ -36,10 +36,23 @@ let CSPDirectivesBuilder = class CSPDirectivesBuilder {
         this.logger.info('Default CSP directives', defaultDirectives);
         const directives = { ...defaultDirectives };
         if (!this.environmentManager.isProd()) {
+            // In dev mode, we allow ourselves to remove this directive.
+            // It is necessary when testing from an external device and accessing the server via 192.168.x.x for example
+            // Otherwise the requests are upgraded and it doesn't work since there is no HTTPS in localhost
+            // Source : https://stackoverflow.com/questions/66599655/how-to-enable-and-disable-upgradeinsecurerequests-csp-directive-using-helmet-4-4
             this.logger.warn('Disabling upgrade-insecure-requests');
             directives['upgrade-insecure-requests'] = null;
+            // In dev mode, NextJS uses eval
+            // Enabling it prevents the following error from occurring in the console
+            // Uncaught EvalError: call to eval() blocked by CSP NextJS
+            // Source : https://github.com/vercel/next.js/discussions/17396
             this.logger.warn('Enabling unsafe-eval');
             directives[CSPDirectivesBuilder_1.SCRIPT_SRC]?.push("'unsafe-eval'");
+            // In dev mode, React Dev Tools use inline injection
+            // Enabling it prevents the following error from occurring in the console
+            // Content Security Policy: The page’s settings blocked the loading of a resource at inline (“script-src”).
+            // Download the React DevTools for a better development experience: https://reactjs.org/link/react-devtools
+            // Uncaught TypeError: hook.sub is not a function
             this.logger.warn('Enabling unsafe-inline');
             directives[CSPDirectivesBuilder_1.SCRIPT_SRC]?.push("'unsafe-inline'");
         }

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

@@ -21,11 +21,14 @@ let CustomerFacingErrorBuilder = class CustomerFacingErrorBuilder {
     }
     exec({ error }) {
         if (error instanceof CustomError) {
+            // It's already ready to be sent as is
             return {
                 error,
             };
         }
         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"...
         return {
             error: new InternalServerError(this.environmentManager.isProd()
                 ? undefined

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

@@ -31,6 +31,7 @@ let PrivateApiKeyAuthenticationChecker = class PrivateApiKeyAuthenticationChecke
         if (!exists) {
             return null;
         }
+        // TODO : Improve this by fetching data from a data store for example
         return {
             organization: {
                 id: '',

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

@@ -27,7 +27,7 @@ let PublicApiKeyChecker = class PublicApiKeyChecker {
     }
     async exec({ checkType = DEFAULT_UC_SEC_PAKCT, value, }) {
         this.logger.trace('Checking apiKey', { checkType, value });
-        let allowed = false;
+        let allowed = false; // By default it's not allowed
         switch (checkType) {
             case 'off':
                 allowed = true;

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

@@ -27,10 +27,10 @@ let RequestChecker = class RequestChecker {
         };
     }
     exec({ secure, url, xForwardedProtoHeader }) {
-        const isSecure = secure;
-        const isSecureForwarded = xForwardedProtoHeader === 'https';
-        const isNotProd = !this.environmentManager.isProd();
-        const isSSLCertificateCheck = !!url.match(/^\/\.well-known\/acme-challenge\/(.*)/);
+        const isSecure = secure; // https://localhost:8443
+        const isSecureForwarded = xForwardedProtoHeader === 'https'; // https://domain.com => http://localhost:8080
+        const isNotProd = !this.environmentManager.isProd(); // http://localhost:8443
+        const isSSLCertificateCheck = !!url.match(/^\/\.well-known\/acme-challenge\/(.*)/); // http://localhost:8443/.well-known/acme-challenge/ywml7k8e8qxdjwFf1pN4hIKWJ1Jrc0CvAP3t9PSmnzw
         this.logger.trace('Request checker', {
             isNotProd,
             isSSLCertificateCheck,
@@ -39,6 +39,7 @@ let RequestChecker = class RequestChecker {
         });
         const allowed = isSecure || isSecureForwarded || isNotProd || isSSLCertificateCheck;
         if (!allowed) {
+            // Not sure it's the right HTTP status to send in these cases but not a big deal for now
             throw new ForbiddenError();
         }
     }

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

@@ -5,5 +5,10 @@ export interface RequestHandlerInputRaw<I extends UCInput | undefined = undefine
     appManifest: AppManifest;
     envelope: HTTPDataEnvelope;
     ucd: UCDef<I, OPI0, OPI1>;
+    /**
+     * It is not injected in the handler constructor because it must be the same as the one used in ServerManager.
+     *
+     * And in some cases, this latter is specific to a context : for instance in automated tests.
+     */
     ucManager: UCManager;
 }

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

@@ -20,6 +20,11 @@ let RequestLogger = class RequestLogger {
     }
     exec({ body, method, url }) {
         const prefix = [method, url].join(' ');
+        // By security, we don't log the body in production, in case it contains sensitive info (e.g. password when authenticating).
+        // That being said, in some cases, it can be handy to investigate issues.
+        // Let's think about it and how we can do it properly.
+        // One way is to this.logger.trace the body, considering it will never be the default in production since it produces too many logs.
+        // TODO : Consider logging request body even in production
         if (this.environmentManager.isProd()) {
             this.logger.debug(prefix);
             return;

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

@@ -31,9 +31,28 @@ export interface ServerManagerSettings extends ServerManagerAuthSettings, Settin
 }
 export interface ServerManager extends Initializable {
     overrideUCManager(ucManager: UCManager): void;
+    /**
+     * Mount the use case as an endpoint
+     * @param appManifest
+     * @param ucd
+     * @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 static directory at `/`
+     * @param dirPath
+     */
     mountStaticDir(dirPath: DirPath): Promise<void>;
+    /**
+     * Start listening on the specific host and port
+     */
     start(): Promise<void>;
+    /**
+     * Stop listening
+     */
     stop(): Promise<void>;
+    /**
+     * Warm up with things that must be done after the routes have been defined (e.g. error middleware, etc.)
+     */
     warmUp(): Promise<void>;
 }

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

@@ -1,2 +1,5 @@
 import type { ServerManagerSettings } from './ServerManager.js';
+/**
+ * @see TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS
+ */
 export declare const TARGET_DEFAULT_SERVER_MANAGER_SETTINGS: ServerManagerSettings;

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

@@ -1,3 +1,6 @@
+/**
+ * @see TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS
+ */
 export const TARGET_DEFAULT_SERVER_MANAGER_SETTINGS = {
     server_basic_auth_entries: {},
     server_binding_host: 'localhost',

package/dist/esm/target/lib/web/input.d.ts

@@ -1,9 +1,30 @@
 import { type DataType, type ErrorMessage, type HTMLInputType } from '../../../dt/index.js';
 import { type UCExecState, type UCInputField } from '../../../uc/index.js';
 export interface HTMLInputDef {
+    /**
+     * Internal types that are not part of the W3C spec
+     *
+     * @see node_modules/@types/react/index.d.ts#InputHTMLAttributes
+     */
     internal?: {
+        /**
+         * When a fiels is `multiline`, you should probably render a `<textarea />` in place of an `<input />`.
+         */
         multiline?: boolean | undefined;
     };
+    /**
+     * Fields that are part of the W3C spec
+     *
+     * These are safe to destructure directly in an `<input />` component.
+     *
+     * Note that they come with their camel case form, à la React.
+     * The reason is that it's easier to transform this to the original spec (`maxLength` => `maxlength`) vs doing the opposite (`maxlength` > `maxLength`).
+     * In the first case, we can simply call `.toLowerCase()` on the keys, while in the second, we'd need a dedicated function that "camel-cases" a string.
+     *
+     * @example `<input {...attrs.spec} />`
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attributes
+     * @see node_modules/@types/react/index.d.ts `InputHTMLAttributes`
+     */
     spec?: {
         'aria-errormessage'?: string | undefined;
         'aria-invalid'?: boolean | undefined;

package/dist/esm/target/lib/web/input.js

@@ -6,6 +6,7 @@ export function htmlInputDef(field, execState, errMsg) {
         spec: {},
     };
     if (!def.internal || !def.spec) {
+        // Just a guard to safely type the rest of the function without using !
         return def;
     }
     const { key, def: fDef } = field;
@@ -13,11 +14,14 @@ export function htmlInputDef(field, execState, errMsg) {
     def.spec.disabled = ucIsDisabled(execState);
     def.spec.id = ucifId(key);
     def.spec.name = key;
+    // Testing the types by usage probability to make the if/else evaluation stop ideally earlier
     if (fType instanceof TString) {
         const constraints = fType.getConstraints();
         if (constraints) {
             def.spec.maxLength = constraints.maxLength;
             def.spec.minLength = constraints.minLength;
+            // https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/pattern
+            // > No forward slashes should be specified around the pattern text
             def.spec.pattern = constraints.format?.regexp?.source;
         }
         def.internal.multiline = fType.isPotentiallyLong();

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

@@ -57,7 +57,7 @@ let NodeCoreCLIManager = class NodeCoreCLIManager {
     }
     parseArgsConfig(uc) {
         const config = {
-            allowPositionals: true,
+            allowPositionals: true, // For the command name
             strict: true,
         };
         if (uc.inputFields.length === 0) {
@@ -68,7 +68,7 @@ let NodeCoreCLIManager = class NodeCoreCLIManager {
             const { def } = f;
             let defaultValue = def.type.getDefaultValue();
             if (typeof defaultValue === 'number') {
-                defaultValue = defaultValue.toString();
+                defaultValue = defaultValue.toString(); // parseArgs does not accept numbers as default value
             }
             const [isRepeatable, _max] = ucifRepeatability(def);
             const type = def.type instanceof TBoolean ? 'boolean' : 'string';

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

@@ -77,6 +77,8 @@ let NodeExpressServerManager = class NodeExpressServerManager {
     async init() {
         this.runtime = express();
         this.runtime.use(this.helmetMB.exec({}));
+        // TODO : Add FileStorageManager (Local, S3, FSBucket)
+        // Right now, the files are only stored locally. We need more flexibility. Maybe we can also install https://imgproxy.net.
         this.runtime.use(fileUpload({
             createParentPath: true,
             debug: this.s().logger_level === 'trace',
@@ -125,6 +127,8 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         if (!this.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 (!this.server) {
                 return resolve();
@@ -138,6 +142,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         });
     }
     async warmUp() {
+        // Always at the "almost" last position to handle all the errors (from other middlewares and request handlers)
         this.runtime.use(this.errorMB.exec({}));
     }
     async createServer() {

package/dist/esm/target/node-express-server/lib/AuthCookieCreator.js

@@ -35,7 +35,7 @@ let AuthCookieCreator = class AuthCookieCreator {
                 httpOnly: this.s().server_cookies_http_only,
                 sameSite: this.s().server_cookies_same_site,
                 secure: this.s().server_cookies_secure,
-                signed: false,
+                signed: false, // Not signing to keep it simple and btw, the JWT is already signed
             },
             val: jwt,
         };

package/dist/esm/target/node-express-server/middlewares/AuthenticationCheckerMiddlewareBuilder.js

@@ -51,6 +51,7 @@ let AuthenticationCheckerMiddlewareBuilder = class AuthenticationCheckerMiddlewa
                 nextFn();
             }
             catch (err) {
+                // Always catch otherwise it breaks the middleware chain and hangs forever
                 nextFn(err);
             }
         };

package/dist/esm/target/node-express-server/middlewares/PublicApiKeyCheckerMiddlewareBuilder.js

@@ -35,6 +35,7 @@ let PublicApiKeyCheckerMiddlewareBuilder = class PublicApiKeyCheckerMiddlewareBu
                 nextFn();
             }
             catch (err) {
+                // Always catch otherwise it breaks the middleware chain and hangs forever
                 nextFn(err);
             }
         };

package/dist/esm/target/node-express-server/middlewares/RequestCheckerMiddlewareBuilder.js

@@ -28,6 +28,7 @@ let RequestCheckerMiddlewareBuilder = class RequestCheckerMiddlewareBuilder {
                 nextFn();
             }
             catch (err) {
+                // Always catch otherwise it breaks the middleware chain and hangs forever
                 nextFn(err);
             }
         };

package/dist/esm/target/node-express-server/middlewares/RequestHandlerMiddlewareBuilder.js

@@ -49,6 +49,8 @@ let RequestHandlerMiddlewareBuilder = class RequestHandlerMiddlewareBuilder {
                     if (ucor.canItem00()) {
                         item = ucor.item00().item;
                     }
+                    // Be careful with this, as some are incompatible.
+                    // For instance, if there is a REDIRECT and then a CLEAR_AUTH, the latter won't be executed as we return after the redirect.
                     for (const se of sideEffects) {
                         const { type } = se;
                         switch (type) {
@@ -74,6 +76,7 @@ let RequestHandlerMiddlewareBuilder = class RequestHandlerMiddlewareBuilder {
                 res.send(output && transform ? transform(output) : output);
             }
             catch (err) {
+                // Always catch otherwise it breaks the middleware chain and hangs forever
                 nextFn(err);
             }
         };
@@ -82,6 +85,7 @@ let RequestHandlerMiddlewareBuilder = class RequestHandlerMiddlewareBuilder {
         switch (envelope) {
             case 'form-data': {
                 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)
@@ -89,6 +93,8 @@ let RequestHandlerMiddlewareBuilder = class RequestHandlerMiddlewareBuilder {
                             : this.toFile(value);
                     }
                 }
+                // TODO : Change this ugly code
+                // When a field has multiple values, they key is `field[]` and not `field`
                 const sanitized = {};
                 for (const [k, v] of Object.entries(input)) {
                     const sanitizedKey = k.split('[')[0];
@@ -96,6 +102,8 @@ let RequestHandlerMiddlewareBuilder = class RequestHandlerMiddlewareBuilder {
                         continue;
                     }
                     sanitized[sanitizedKey] = v;
+                    // For some reason, when there is only one value, it is received as scalar and not as an array
+                    // Even if there is only one, we want an array
                     if (k.includes('[') && !Array.isArray(v)) {
                         sanitized[sanitizedKey] = [v];
                     }

package/dist/esm/target/node-express-server/middlewares/RequestLoggerMiddlewareBuilder.js

@@ -31,6 +31,7 @@ let RequestLoggerMiddlewareBuilder = class RequestLoggerMiddlewareBuilder {
             }
             catch (err) {
                 this.logger.error(err);
+                // Continue as usual : the user shouldn't be impacted if we have issues logging the requests
                 nextFn();
             }
         };

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

@@ -7,6 +7,16 @@ import type { Configurable, LoggerSettings, SettingsManager } from '../../std/in
 import { UCBuilder, type UCDef, type UCHTTPContract, type UCInput, type UCManager, type UCOPIBase } from '../../uc/index.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 type S = Pick<LoggerSettings, 'logger_level'>;
+/**
+ * A simple MCP Server implementation
+ *
+ * Although it implements {@link ServerManager}, this implementation is not necessarily a "server".
+ * Indeed, it uses a local `Transport` so it must be considered the same as a {@link NodeCoreCLIManager}.
+ * Therefore, it calls `execClient` and not `execServer`.
+ * This way, Claude AI, or any other client is just a wrapper on top of it.
+ *
+ * @alpha This implementation still has lots of TODOs and has not been tested in real conditions. It needs to be stabilized before usage.
+ */
 export declare class NodeLocalStdioMCPServerManager implements Configurable<S>, ServerManager {
     private productManifest;
     private settingsManager;

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

@@ -17,6 +17,16 @@ import { inject, injectable } from 'inversify';
 import { WordingManager } from '../../i18n/index.js';
 import { UCBuilder, ucMountingPoint, ucifIsMandatory, } from '../../uc/index.js';
 import { propertyType, resError, resObj } from './funcs.js';
+/**
+ * A simple MCP Server implementation
+ *
+ * Although it implements {@link ServerManager}, this implementation is not necessarily a "server".
+ * Indeed, it uses a local `Transport` so it must be considered the same as a {@link NodeCoreCLIManager}.
+ * Therefore, it calls `execClient` and not `execServer`.
+ * This way, Claude AI, or any other client is just a wrapper on top of it.
+ *
+ * @alpha This implementation still has lots of TODOs and has not been tested in real conditions. It needs to be stabilized before usage.
+ */
 let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
     productManifest;
     settingsManager;
@@ -55,6 +65,9 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
         });
         if (this.s().logger_level !== 'error') {
             const message = 'Set the logging_level to "error" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)';
+            // Depending on the `Logger` implementation, this.logger.error() might not write to stderr (e.g. can write to a file).
+            // That's why we explicitly write to stdout by calling console.error().
+            // biome-ignore lint/suspicious/noConsole: we want it
             console.error(new Error(message));
         }
     }
@@ -112,6 +125,7 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
     }
     async execRequest(request) {
         const { name, arguments: args } = request.params;
+        // TODO : Check authentication in some way (see if MCP handles it)
         const auth = null;
         try {
             const route = this.tools.get(name);

package/dist/esm/target/react-native-pure/UCAutoExecLoader.d.ts

@@ -0,0 +1,2 @@
+import { type ReactElement } from 'react';
+export declare function UCAutoExecLoader(): ReactElement;

package/dist/esm/target/react-native-pure/UCAutoExecLoader.js

@@ -0,0 +1,5 @@
+import React, {} from 'react';
+import { ActivityIndicator } from 'react-native';
+export function UCAutoExecLoader() {
+    return React.createElement(ActivityIndicator, null);
+}

package/dist/esm/target/react-native-pure/UCEntrypointTouchable.d.ts

@@ -0,0 +1,4 @@
+import { type ReactElement } from 'react';
+import type { UCInput, UCOPIBase } from '../../uc/index.js';
+import type { UCEntrypointTouchableProps } from '../lib/react/touchable.js';
+export declare function UCEntrypointTouchable<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ onPress, wording, }: UCEntrypointTouchableProps<I, OPI0, OPI1>): ReactElement;

package/dist/esm/target/react-native-pure/UCEntrypointTouchable.js

@@ -0,0 +1,6 @@
+import React, {} from 'react';
+import { Pressable, Text } from 'react-native';
+export function UCEntrypointTouchable({ onPress, wording, }) {
+    return (React.createElement(Pressable, { onPress: onPress },
+        React.createElement(Text, null, wording.label)));
+}

package/dist/esm/target/react-native-pure/UCExecTouchable.d.ts

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

package/dist/esm/target/react-native-pure/UCExecTouchable.js

@@ -0,0 +1,9 @@
+import React, {} from 'react';
+import { Pressable, Text } from 'react-native';
+import { useDIContext } from '../lib/react/DIContextProvider.js';
+export function UCExecTouchable({ disabled, execState, onSubmit, uc, }) {
+    const { wordingManager } = useDIContext();
+    const label = wordingManager.ucISubmit(uc.def, execState);
+    return (React.createElement(Pressable, { disabled: disabled, onPress: onSubmit },
+        React.createElement(Text, null, label)));
+}