libmodulor 0.19.0 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # CHANGELOG
 
+## v0.20.0 (2025-07-26)
+
+**Added**
+
+- Add ability to stream data in `ShellCommandExecutor`
+- Stream output with color when using the `TestApp` command
+- Check app sources before executing the test in `TestApp` : this allows to spot errors earlier and avoid cryptic exec errors when the sources are not valid (don't forget to re-generate the tests with `pnpm libmodulor GenerateAppsTests` and use `--updateSnapshots` the next time you call `TestApp --appName YourApp`)
+
+**Misc**
+
+- Add the `Toolbox` app to `examples` (for docs)
+- Expose `UC_POLICY_FILE_NAME_EXT` and `UC_POLICY_FILE_NAME_SUFFIX` in the convention
+- Move `examples/embedded` to `examples/standalone`
+- Add the `GeocodeAddress` UCD to `Toolbox` (for docs)
+- Add the `MyRunningMap` app to `examples` (for docs)
+- Harmonize `examples` apps testing
+
 ## v0.19.0 (2025-06-20)
 
 **BREAKING**

package/README.md

@@ -17,4 +17,4 @@ If you think you can help in any way, feel free to contact me (cf. `author` in `
 
 ## ⚖️ License
 
-[LGPL-3.0](https://github.com/c100k/libmodulor/blob/v0.19.0/LICENSE)
+[LGPL-3.0](https://github.com/c100k/libmodulor/blob/v0.20.0/LICENSE)

package/dist/esm/apps/Helper/src/lib/project.js

@@ -81,21 +81,21 @@ export const PACKAGE_JSON = (name) => `{
         "test": "tsc && vitest run --passWithNoTests"
     },
     "dependencies": {
-        "inversify": "^7.5.2",
+        "inversify": "^7.6.1",
         "libmodulor": "latest",
         "reflect-metadata": "^0.2.2"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.0.0",
-        "@types/node": "^22.15.32",
+        "@biomejs/biome": "^2.1.2",
+        "@types/node": "^22.16.5",
         "@vitest/coverage-v8": "^3.2.4",
         "buffer": "^6.0.3",
         "cookie-parser": "^1.4.7",
         "express": "^5.1.0",
-        "express-fileupload": "^1.5.1",
-        "fast-check": "^4.1.1",
+        "express-fileupload": "^1.5.2",
+        "fast-check": "^4.2.0",
         "helmet": "^8.1.0",
-        "jose": "^6.0.11",
+        "jose": "^6.0.12",
         "typescript": "^5.8.3",
         "vite": "^6.3.5",
         "vitest": "^3.2.4"

package/dist/esm/convention.d.ts

@@ -44,3 +44,5 @@ export declare const UC_OPI_BASE: string;
 export declare const UC_OPI_SUFFIX: string;
 export declare const UC_POLICY_SUFFIX: string;
 export declare const UC_POLICY_SUFFIX_FULL: string;
+export declare const UC_POLICY_FILE_NAME_EXT: string;
+export declare const UC_POLICY_FILE_NAME_SUFFIX: string;

package/dist/esm/convention.js

@@ -54,3 +54,5 @@ export const UC_OPI_BASE = 'UCOPIBase';
 export const UC_OPI_SUFFIX = 'OPI';
 export const UC_POLICY_SUFFIX = 'Policy';
 export const UC_POLICY_SUFFIX_FULL = `UC${UC_POLICY_SUFFIX}`;
+export const UC_POLICY_FILE_NAME_EXT = '.ts';
+export const UC_POLICY_FILE_NAME_SUFFIX = `${UC_POLICY_SUFFIX_FULL}${UC_POLICY_FILE_NAME_EXT}`;

package/dist/esm/std/ShellCommandExecutor.d.ts

@@ -12,6 +12,7 @@ export interface ShellCommandExecutorInput {
         args?: ShellCommandExecutorCommandArg[];
         cwd?: FilePath;
         env?: ShellCommandExecutorEnv;
+        streamData?: boolean;
     };
 }
 export type ShellCommandExecutorOutput = string;

package/dist/esm/std/impl/NodeSpawnShellCommandExecutor.js

@@ -17,9 +17,15 @@ let NodeSpawnShellCommandExecutor = class NodeSpawnShellCommandExecutor {
             });
             proc.stderr.on('data', (chunk) => {
                 stderr += chunk;
+                if (opts?.streamData) {
+                    process.stderr.write(chunk);
+                }
             });
             proc.stdout.on('data', (chunk) => {
                 stdout += chunk;
+                if (opts?.streamData) {
+                    process.stdout.write(chunk);
+                }
             });
             proc.on('error', (err) => {
                 reject(err);

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

@@ -17,7 +17,7 @@ export function UCContainer({ children, uc, }) {
     }, [uc, ucExecChecker]);
     if (isAllowed === undefined) {
         // TODO : Add some loader while we check if can do
-        return _jsx(_Fragment, {});
+        return null;
     }
     if (isAllowed === false) {
         return null;

package/dist/esm/testing/AppTester.d.ts

@@ -1,7 +1,7 @@
 import type { FilePath } from '../dt/index.js';
 import type { ServerClientManagerSettings } from '../target/lib/client/ServerClientManager.js';
 import type { ServerManager } from '../target/lib/server/ServerManager.js';
-import { type UCAuth, UCBuilder, type UCDef, type UCInput, type UCOPIBase } from '../uc/index.js';
+import { type UCAuth, UCBuilder, type UCDef, type UCInput, type UCName, type UCOPIBase } from '../uc/index.js';
 import type { SrcImporter } from '../utils/index.js';
 import type { AppTesterConfigurator } from './AppTesterConfigurator.js';
 import type { AppTesterCtx, AppTesterUCDRef } from './ctx.js';
@@ -50,6 +50,7 @@ export declare class AppTester {
      * This can happen in case of circular dependencies for example.
      */
     private safeSrcImporter;
+    private ucds;
     private testResults;
     private testSummary;
     private ucDefSourcesCheckerOutput;
@@ -59,13 +60,15 @@ export declare class AppTester {
     checkAppIndex(): Promise<void>;
     checkAppManifest(): Promise<void>;
     checkUCDSources(): Promise<void>;
-    checkUC(ucdRef: AppTesterUCDRef): Promise<UCDef>;
+    checkUC(ucdRef: AppTesterUCDRef): Promise<void>;
     execFlow(flow: AppTesterFlow): Promise<AppTesterFlowExecOutput>;
     execMonkeyTest<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>, input: I): Promise<UCExecutorExecOutput<I, OPI0, OPI1>>;
     execUC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(input: Omit<UCExecutorInput<I, OPI0, OPI1>, 'appManifest'>, flow?: AppTesterFlow): Promise<AppTestSuiteTestResult<I, OPI0, OPI1>>;
     finalize(): Promise<void>;
     getCtx(): AppTesterCtx;
+    getUCD<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucName: UCName): UCDef<I, OPI0, OPI1>;
     init({ appPath, configurator, serverClientSettings, srcImporter, }: AppTesterInitArgs): Promise<void>;
+    initForUCExec(): Promise<void>;
     ucTestData(ucdRef: AppTesterUCDRef): Promise<AppTesterUCTestData[]>;
     private bindI18n;
     private bindServerClientSettings;

package/dist/esm/testing/AppTester.js

@@ -29,6 +29,7 @@ import { AppManifestChecker } from './workers/checkers/AppManifestChecker.js';
 import { UCDefChecker } from './workers/checkers/UCDefChecker.js';
 import { UCDefSourcesChecker, } from './workers/checkers/UCDefSourcesChecker.js';
 import { UCExecutor, } from './workers/UCExecutor.js';
+const ERR_UCD_NOT_FOUND = (ucName) => `Could not find a ucd for ${ucName}`;
 let AppTester = class AppTester {
     appDocsEmitter;
     appFolderChecker;
@@ -50,6 +51,8 @@ let AppTester = class AppTester {
      */
     safeSrcImporter;
     // biome-ignore lint/suspicious/noExplicitAny: can be anything
+    ucds;
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     testResults;
     testSummary;
     ucDefSourcesCheckerOutput;
@@ -66,6 +69,7 @@ let AppTester = class AppTester {
         this.ucDefChecker = ucDefChecker;
         this.ucDefSourcesChecker = ucDefSourcesChecker;
         this.ucExecutor = ucExecutor;
+        this.ucds = new Map();
         this.testResults = [];
         this.testSummary = {
             counts: {
@@ -115,13 +119,13 @@ let AppTester = class AppTester {
         });
     }
     async checkUC(ucdRef) {
-        const { errors } = await this.ucDefChecker.exec({ ucdRef });
+        const { errors, ucd } = await this.ucDefChecker.exec({ ucdRef });
         if (errors.length > 0) {
             throw new Error(errors[0]);
         }
-        const { source } = ucdRef;
-        const ucd = source[`${Object.keys(source)[0]}`];
-        return ucd;
+        if (ucd) {
+            this.ucds.set(ucdRef.name, ucd);
+        }
     }
     async execFlow(flow) {
         const output = [];
@@ -226,6 +230,13 @@ let AppTester = class AppTester {
     getCtx() {
         return this.ctx;
     }
+    getUCD(ucName) {
+        const ucd = this.ucds.get(ucName);
+        if (!ucd) {
+            throw new Error(ERR_UCD_NOT_FOUND(ucName));
+        }
+        return ucd;
+    }
     async init({ appPath, configurator, serverClientSettings, srcImporter, }) {
         this.configurator = configurator;
         this.safeSrcImporter = (path) => Promise.race([
@@ -243,6 +254,8 @@ let AppTester = class AppTester {
         await this.configurator.seed(this.ctx);
         await this.bindI18n();
         await this.bindServerClientSettings(serverClientSettings);
+    }
+    async initForUCExec() {
         await this.initI18n();
         await this.initServer();
     }

package/dist/esm/testing/impl/VitestAppTestSuiteEmitter.js

@@ -52,14 +52,14 @@ const template = (serverPortRangeStart, idx, monkeyTestingTimeoutInMs) => `/*
 import { join } from 'node:path';
 
 import {
-    assert,
     type Arbitrary,
     type AsyncCommand,
-    type ModelRunSetup,
     anything,
+    assert,
     asyncModelRun,
     asyncProperty,
     commands,
+    type ModelRunSetup,
     record,
 } from 'fast-check';
 import {
@@ -70,7 +70,7 @@ import {
     type UCInput,
 } from 'libmodulor';
 import { newNodeAppTester } from 'libmodulor/node-test';
-import { afterAll, afterEach, describe, expect, test } from 'vitest';
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest';
 
 import { Configurator } from './Configurator.js';
 
@@ -84,116 +84,92 @@ const runner = await newNodeAppTester(${serverPortRangeStart}, ${idx}, {
 const ctx = runner.getCtx();
 const logger = ctx.container.get<Logger>('Logger');
 
+const flows = await configurator.flows();
+
 afterAll(async () => {
     await runner.finalize();
 });
 
-test('Sources should be valid', async () => {
-    await runner.checkUCDSources();
-});
-
-test('Folder should be valid', async () => {
-    await runner.checkAppFolder();
-});
-
-test('${APP_MANIFEST_NAME} should be valid', async () => {
-    await runner.checkAppManifest();
-});
+describe('Check', () => {
+    test('Sources should be valid', async () => {
+        await runner.checkUCDSources();
+    });
 
-test('${APP_I18N_NAME} should be valid', async () => {
-    await runner.checkAppI18n();
-});
+    test('Folder should be valid', async () => {
+        await runner.checkAppFolder();
+    });
 
-test('${APP_INDEX_NAME} should be valid', async () => {
-    await runner.checkAppIndex();
-});
+    test('${APP_MANIFEST_NAME} should be valid', async () => {
+        await runner.checkAppManifest();
+    });
 
-const flows = await configurator.flows();
-describe.runIf(flows.length > 0)('Flows', async () => {
-    afterEach(async () => {
-        await configurator.clearExecution(ctx);
+    test('${APP_I18N_NAME} should be valid', async () => {
+        await runner.checkAppI18n();
     });
 
-    test.each(flows)('should execute flow $name', async (flow) => {
-        const output = await runner.execFlow(flow);
+    test('${APP_INDEX_NAME} should be valid', async () => {
+        await runner.checkAppIndex();
+    });
 
-        for (const out of output) {
-            if (out.err !== null) {
-                if (!(out.err instanceof CustomError)) {
-                    logger.error(out.err);
-                }
-                expect(out.err).toBeInstanceOf(CustomError);
-            }
-        }
+    describe.runIf(ctx.ucdRefs.length > 0)('Use Cases', () => {
+        describe.each(ctx.ucdRefs)('$name', async (ucdRef) => {
+            test('should be valid', async () => {
+                await runner.checkUC(ucdRef);
+            });
+        });
     });
 });
 
-const { ucdRefs } = ctx;
-describe.runIf(ucdRefs.length > 0)('Use Cases', () => {
-    describe.each(ucdRefs)('$name', async (ucdRef) => {
+describe('Run', async () => {
+    beforeAll(async () => {
+        await runner.initForUCExec();
+    });
+
+    describe.runIf(flows.length > 0)('Flows', async () => {
         afterEach(async () => {
             await configurator.clearExecution(ctx);
         });
 
-        // biome-ignore lint/suspicious/noExplicitAny: can be anything
-        let ucd: UCDef<any, any, any>;
-
-        test('should be valid', async () => {
-            ucd = await runner.checkUC(ucdRef);
-        });
-
-        const data = await runner.ucTestData(ucdRef);
-
-        test.each(data)(
-            'should execute with auth $authName and input $inputFillerName',
-            async ({ auth, authName, inputFiller, inputFillerName }) => {
-                const { out, sideEffects } = await runner.execUC({
-                    auth,
-                    authName: authName as UCAuthSetterName,
-                    inputFiller,
-                    inputFillerName,
-                    ucd,
-                });
+        test.each(flows)('should execute flow $name', async (flow) => {
+            const output = await runner.execFlow(flow);
 
+            for (const out of output) {
                 if (out.err !== null) {
                     if (!(out.err instanceof CustomError)) {
                         logger.error(out.err);
                     }
                     expect(out.err).toBeInstanceOf(CustomError);
                 }
+            }
+        });
+    });
 
-                const { hash } = out;
-                const assertion = hash
-                    ? (await configurator.specificAssertions())?.get(hash)
-                    : undefined;
-                if (assertion) {
-                    expect(out).toSatisfy(assertion);
-                } else {
-                    expect({ out, sideEffects }).toMatchSnapshot(
-                        \`hash = \${hash\}\`,
-                    );
-                }
-            },
-        );
-
-        test('should execute with monkey testing', async () => {
-            // Given
-            // biome-ignore lint/complexity/noBannedTypes: nothing for now
-            type Model = {};
-            // biome-ignore lint/complexity/noBannedTypes: nothing for now
-            type RealSystem = {};
-
-            class MyCommand<I extends UCInput | undefined = undefined>
-                implements AsyncCommand<Model, RealSystem>
-            {
-                constructor(private input: I) {}
-
-                public check(_m: Readonly<Model>): boolean {
-                    return true;
-                }
+    describe.runIf(ctx.ucdRefs.length > 0)('Use Cases', () => {
+        describe.each(ctx.ucdRefs)('$name', async (ucdRef) => {
+            afterEach(async () => {
+                await configurator.clearExecution(ctx);
+            });
+
+            // biome-ignore lint/suspicious/noExplicitAny: can be anything
+            let ucd: UCDef<any, any, any>;
 
-                public async run(_m: Model, _r: RealSystem): Promise<void> {
-                    const out = await runner.execMonkeyTest(ucd, this.input);
+            beforeAll(() => {
+                // biome-ignore lint/suspicious/noExplicitAny: can be anything
+                ucd = runner.getUCD<any, any, any>(ucdRef.name);
+            });
+
+            const data = await runner.ucTestData(ucdRef);
+
+            test.each(data)(
+                'should execute with auth $authName and input $inputFillerName',
+                async ({ auth, authName, inputFiller, inputFillerName }) => {
+                    const { out, sideEffects } = await runner.execUC({
+                        auth,
+                        authName: authName as UCAuthSetterName,
+                        inputFiller,
+                        inputFillerName,
+                        ucd,
+                    });
 
                     if (out.err !== null) {
                         if (!(out.err instanceof CustomError)) {
@@ -201,41 +177,82 @@ describe.runIf(ucdRefs.length > 0)('Use Cases', () => {
                         }
                         expect(out.err).toBeInstanceOf(CustomError);
                     }
-                }
 
-                public toString(): string {
-                    return \`\${ucd.metadata.name\}(\${JSON.stringify(this.input)\})\`;
+                    const { hash } = out;
+                    const assertion = hash
+                        ? (await configurator.specificAssertions())?.get(hash)
+                        : undefined;
+                    if (assertion) {
+                        expect(out).toSatisfy(assertion);
+                    } else {
+                        expect({ out, sideEffects }).toMatchSnapshot(
+                            \`hash = \${hash\}\`,
+                        );
+                    }
+                },
+            );
+
+            test('should execute with monkey testing', async () => {
+                // Given
+                // biome-ignore lint/complexity/noBannedTypes: nothing for now
+                type Model = {};
+                // biome-ignore lint/complexity/noBannedTypes: nothing for now
+                type RealSystem = {};
+
+                class MyCommand<I extends UCInput | undefined = undefined>
+                    implements AsyncCommand<Model, RealSystem>
+                {
+                    constructor(private input: I) {}
+
+                    public check(_m: Readonly<Model>): boolean {
+                        return true;
+                    }
+
+                    public async run(_m: Model, _r: RealSystem): Promise<void> {
+                        const out = await runner.execMonkeyTest(ucd, this.input);
+
+                        if (out.err !== null) {
+                            if (!(out.err instanceof CustomError)) {
+                                logger.error(out.err);
+                            }
+                            expect(out.err).toBeInstanceOf(CustomError);
+                        }
+                    }
+
+                    public toString(): string {
+                        return \`\${ucd.metadata.name\}(\${JSON.stringify(this.input)\})\`;
+                    }
                 }
-            }
 
-            const inputFields = ucd.io.i?.fields;
-            if (!inputFields || Object.keys(inputFields).length > 0) {
-                // Mainly to prevent monkey testing from running indefinitely
-                return;
-            }
+                const inputFields = ucd.io.i?.fields;
+                if (!inputFields || Object.keys(inputFields).length > 0) {
+                    // Mainly to prevent monkey testing from running indefinitely
+                    return;
+                }
 
-            // biome-ignore lint/suspicious/noExplicitAny: can be anything
-            const inputLike: Record<string, Arbitrary<any>> = {};
-            for (const k of Object.keys(inputFields)) {
-                inputLike[k] = anything();
-            }
-            const cmdArbs = record(inputLike, { requiredKeys: [] }).map(
-                (r) => new MyCommand(r),
-            );
+                // biome-ignore lint/suspicious/noExplicitAny: can be anything
+                const inputLike: Record<string, Arbitrary<any>> = {};
+                for (const k of Object.keys(inputFields)) {
+                    inputLike[k] = anything();
+                }
+                const cmdArbs = record(inputLike, { requiredKeys: [] }).map(
+                    (r) => new MyCommand(r),
+                );
 
-            const modelRunSetup: ModelRunSetup<Model, RealSystem> = () => ({
-                model: {},
-                real: {},
-            });
+                const modelRunSetup: ModelRunSetup<Model, RealSystem> = () => ({
+                    model: {},
+                    real: {},
+                });
 
-            // When
-            const property = asyncProperty(commands([cmdArbs]), (cmds) =>
-                asyncModelRun(modelRunSetup, cmds),
-            );
+                // When
+                const property = asyncProperty(commands([cmdArbs]), (cmds) =>
+                    asyncModelRun(modelRunSetup, cmds),
+                );
 
-            // Then
-            await assert(property);
-        }, ${monkeyTestingTimeoutInMs});
+                // Then
+                await assert(property);
+            }, ${monkeyTestingTimeoutInMs});
+        });
     });
 });
 `;

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

@@ -1,11 +1,10 @@
 import type { FilePath } from '../../dt/index.js';
-import type { FSManager, Logger, ShellCommandExecutor } from '../../std/index.js';
+import type { FSManager, ShellCommandExecutor } from '../../std/index.js';
 import type { AppTestSuiteRunner, Input } from '../workers/AppTestSuiteRunner.js';
 export declare class VitestAppTestSuiteRunner implements AppTestSuiteRunner {
     private fsManager;
-    private logger;
     private shellCommandExecutor;
-    constructor(fsManager: FSManager, logger: Logger, shellCommandExecutor: ShellCommandExecutor);
+    constructor(fsManager: FSManager, shellCommandExecutor: ShellCommandExecutor);
     exec({ appPath, skipCoverage, updateSnapshots, }: Input): Promise<void>;
     coverageReportEntrypointPath(appPath: FilePath): Promise<FilePath>;
     private coverageReportPath;

package/dist/esm/testing/impl/VitestAppTestSuiteRunner.js

@@ -14,17 +14,16 @@ import { inject, injectable } from 'inversify';
 import { APP_TEST_DIR_NAME, APP_TEST_REPORTS_DIR_NAME, } from '../../convention.js';
 let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
     fsManager;
-    logger;
     shellCommandExecutor;
-    constructor(fsManager, logger, shellCommandExecutor) {
+    constructor(fsManager, shellCommandExecutor) {
         this.fsManager = fsManager;
-        this.logger = logger;
         this.shellCommandExecutor = shellCommandExecutor;
     }
     async exec({ appPath, skipCoverage, updateSnapshots, }) {
         const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
         const args = [
             'run',
+            '--color',
             '--dir',
             appPath,
         ];
@@ -34,13 +33,13 @@ let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
         if (updateSnapshots) {
             args.push('--update');
         }
-        const output = await this.shellCommandExecutor.exec({
+        await this.shellCommandExecutor.exec({
             bin: './node_modules/.bin/vitest',
             opts: {
                 args,
+                streamData: true,
             },
         });
-        this.logger.info(output);
     }
     async coverageReportEntrypointPath(appPath) {
         return this.fsManager.path(this.coverageReportPath(appPath), 'index.html');
@@ -53,8 +52,7 @@ let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
 VitestAppTestSuiteRunner = __decorate([
     injectable(),
     __param(0, inject('FSManager')),
-    __param(1, inject('Logger')),
-    __param(2, inject('ShellCommandExecutor')),
-    __metadata("design:paramtypes", [Object, Object, Object])
+    __param(1, inject('ShellCommandExecutor')),
+    __metadata("design:paramtypes", [Object, Object])
 ], VitestAppTestSuiteRunner);
 export { VitestAppTestSuiteRunner };

package/dist/esm/testing/workers/checkers/UCDefChecker.d.ts

@@ -1,11 +1,13 @@
 import type { ErrorMessage } from '../../../dt/index.js';
 import type { Worker } from '../../../std/index.js';
+import type { UCDef } from '../../../uc/index.js';
 import type { AppTesterUCDRef } from '../../ctx.js';
 export interface Input {
     ucdRef: AppTesterUCDRef;
 }
 export interface Output {
     errors: ErrorMessage[];
+    ucd: UCDef | null;
 }
 export declare class UCDefChecker implements Worker<Input, Promise<Output>> {
     private output;

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

@@ -15,7 +15,7 @@ const ERR_UCD_NAMES = (fileName, name, ucdKey) => `The file name and the const n
 let UCDefChecker = class UCDefChecker {
     output;
     constructor() {
-        this.output = { errors: [] };
+        this.output = { errors: [], ucd: null };
     }
     async exec({ ucdRef }) {
         const { fileName, source } = ucdRef;
@@ -35,6 +35,9 @@ let UCDefChecker = class UCDefChecker {
             name !== ucdKey.replaceAll(UC_DEF_SUFFIX, '')) {
             this.output.errors.push(ERR_UCD_NAMES(fileName, name, ucdKey));
         }
+        if (this.output.errors.length === 0) {
+            this.output.ucd = ucd;
+        }
         return this.output;
     }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "libmodulor",
     "description": "A TypeScript library to create platform-agnostic applications",
-    "version": "0.19.0",
+    "version": "0.20.0",
     "license": "LGPL-3.0",
     "author": "Chafik H'nini <chafik.hnini@gmail.com>",
     "homepage": "https://libmodulor.c100k.eu",
@@ -81,27 +81,27 @@
         "lint:ci": "biome check"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.0.0"
+        "@biomejs/biome": "^2.1.2"
     },
     "peerDependencies": {
-        "@hono/node-server": "^1.14.4",
-        "@modelcontextprotocol/sdk": "^1.13.0",
-        "@stricli/core": "^1.1.2",
+        "@hono/node-server": "^1.17.1",
+        "@modelcontextprotocol/sdk": "^1.16.0",
+        "@stricli/core": "^1.2.0",
         "buffer": "^6.0.3",
         "cookie-parser": "^1.4.7",
         "express": "^5.1.0",
-        "express-fileupload": "^1.5.1",
-        "fast-check": "^4.1.1",
+        "express-fileupload": "^1.5.2",
+        "fast-check": "^4.2.0",
         "helmet": "^8.1.0",
-        "hono": "^4.8.1",
-        "inversify": "^7.5.2",
-        "jose": "^6.0.11",
+        "hono": "^4.8.5",
+        "inversify": "^7.6.1",
+        "jose": "^6.0.12",
         "knex": "^3.1.0",
-        "next": "^15.3.4",
-        "pg": "^8.16.2",
+        "next": "^15.4.2",
+        "pg": "^8.16.3",
         "react": "^19.1.0",
         "react-dom": "^19.1.0",
-        "react-native": "^0.79.4",
+        "react-native": "^0.79.5",
         "reflect-metadata": "^0.2.2",
         "sqlite3": "^5.1.7",
         "typescript": "^5.8.3",

package/pnpm-workspace.yaml

@@ -1,6 +1,6 @@
 packages:
-  - docs-fd
   - examples/basic
+  - examples/standalone
   - examples/supertrader
 onlyBuiltDependencies:
   - '@biomejs/biome'

package/tsconfig.json

@@ -28,7 +28,6 @@
     },
     "exclude": [
         "dist",
-        "docs-fd",
         "examples/**/dist",
         "examples/**/node_modules",
         "node_modules"