libmodulor 0.18.1 → 0.20.0

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

@@ -0,0 +1,87 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { NotAvailableError, NotCallableError } from '../../error/index.js';
+import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
+import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
+let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
+    serverRequestHandler;
+    settingsManager;
+    ucDataStore;
+    ucManager;
+    runtime;
+    constructor(serverRequestHandler, settingsManager, ucDataStore, ucManager) {
+        this.serverRequestHandler = serverRequestHandler;
+        this.settingsManager = settingsManager;
+        this.ucDataStore = ucDataStore;
+        this.ucManager = ucManager;
+    }
+    s() {
+        return {
+            sewhsm_bindings_uc_data_store: this.settingsManager.get()('sewhsm_bindings_uc_data_store'),
+        };
+    }
+    getRuntime() {
+        return this.runtime;
+    }
+    overrideUCManager(ucManager) {
+        this.ucManager = ucManager;
+    }
+    async init() {
+        throw new NotCallableError('init', 'initSync', 'sync-only');
+    }
+    initSync() {
+        this.runtime = init();
+    }
+    async mount(_appManifest, _ucd, _contract) {
+        throw new NotCallableError('mount', 'mountSync', 'sync-only');
+    }
+    mountSync(appManifest, ucd, contract) {
+        mountHandler(contract, this.runtime, buildHandler(appManifest, ucd, contract, this.serverRequestHandler, this.ucManager, (c) => this.beforeExec(c)));
+    }
+    async mountStaticDir(_dirPath) {
+        throw new NotAvailableError('mountStaticDir');
+    }
+    async start() {
+        throw new NotAvailableError('start');
+    }
+    async stop() {
+        throw new NotAvailableError('stop');
+    }
+    async warmUp() {
+        throw new NotAvailableError('warmUp');
+    }
+    async beforeExec(c) {
+        const { env } = c;
+        if (!env) {
+            return;
+        }
+        const ucDataStoreBinding = this.s().sewhsm_bindings_uc_data_store;
+        if (!ucDataStoreBinding ||
+            !(ucDataStoreBinding in env) ||
+            !('setClient' in this.ucDataStore) ||
+            typeof this.ucDataStore.setClient !== 'function') {
+            return;
+        }
+        this.ucDataStore.setClient(env[ucDataStoreBinding]);
+    }
+};
+SyncEdgeWorkerHonoServerManager = __decorate([
+    injectable(),
+    __param(0, inject(ServerRequestHandler)),
+    __param(1, inject('SettingsManager')),
+    __param(2, inject('UCDataStore')),
+    __param(3, inject('UCManager')),
+    __metadata("design:paramtypes", [ServerRequestHandler, Object, Object, Object])
+], SyncEdgeWorkerHonoServerManager);
+export { SyncEdgeWorkerHonoServerManager };

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

@@ -1,15 +1,16 @@
 import type { AppUCsLoaderInput } from '../../../app/index.js';
 import { ProductUCsLoader } from '../../../product/index.js';
-import type { Logger, Worker } from '../../../std/index.js';
+import type { I18nManager, Logger, Worker } from '../../../std/index.js';
 import { type UCManager } from '../../../uc/index.js';
 import type { ServerManager } from '../server/ServerManager.js';
 type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'>;
 export declare class MCPServerBooter implements Worker<Input, Promise<void>> {
+    private i18nManager;
     private logger;
     private productUCsLoader;
     private serverManager;
     private ucManager;
-    constructor(logger: Logger, productUCsLoader: ProductUCsLoader, serverManager: ServerManager, ucManager: UCManager);
+    constructor(i18nManager: I18nManager, logger: Logger, productUCsLoader: ProductUCsLoader, serverManager: ServerManager, ucManager: UCManager);
     exec({ appsRootPath, srcImporter }: Input): Promise<void>;
 }
 export {};

package/dist/esm/target/lib/mcp-server/MCPServerBooter.js

@@ -14,11 +14,13 @@ import { inject, injectable } from 'inversify';
 import { ProductUCsLoader } from '../../../product/index.js';
 import { ucHTTPContract } from '../../../uc/index.js';
 let MCPServerBooter = class MCPServerBooter {
+    i18nManager;
     logger;
     productUCsLoader;
     serverManager;
     ucManager;
-    constructor(logger, productUCsLoader, serverManager, ucManager) {
+    constructor(i18nManager, logger, productUCsLoader, serverManager, ucManager) {
+        this.i18nManager = i18nManager;
         this.logger = logger;
         this.productUCsLoader = productUCsLoader;
         this.serverManager = serverManager;
@@ -26,6 +28,7 @@ let MCPServerBooter = class MCPServerBooter {
     }
     async exec({ appsRootPath, srcImporter }) {
         try {
+            await this.i18nManager.init();
             await this.serverManager.init();
             const ucs = await this.productUCsLoader.exec({
                 appsRootPath,
@@ -47,10 +50,11 @@ let MCPServerBooter = class MCPServerBooter {
 };
 MCPServerBooter = __decorate([
     injectable(),
-    __param(0, inject('Logger')),
-    __param(1, inject(ProductUCsLoader)),
-    __param(2, inject('ServerManager')),
-    __param(3, inject('UCManager')),
-    __metadata("design:paramtypes", [Object, ProductUCsLoader, Object, Object])
+    __param(0, inject('I18nManager')),
+    __param(1, inject('Logger')),
+    __param(2, inject(ProductUCsLoader)),
+    __param(3, inject('ServerManager')),
+    __param(4, inject('UCManager')),
+    __metadata("design:paramtypes", [Object, Object, ProductUCsLoader, Object, Object])
 ], MCPServerBooter);
 export { MCPServerBooter };

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/target/lib/server/ServerBooter.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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