libmodulor 0.29.0 → 0.31.0

package/dist/esm/instrumentation/instrumentation-otl.js

@@ -0,0 +1,119 @@
+import { context, SpanStatusCode, trace } from '@opentelemetry/api';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, } from '@opentelemetry/instrumentation';
+const LIB_NAME = 'libmodulor';
+const LIB_VERSION = '';
+const LIB_MIN_VERSION = '*';
+const NAME = `instrumentation-${LIB_NAME}`;
+const TRACABLES = {
+    [LIB_NAME]: {
+        SimpleUCManager: [
+            'commitTx',
+            'confirmClient',
+            'execClient',
+            'execServer',
+            'initServer',
+            'persist',
+            'persistProjection',
+            'rollbackTx',
+        ],
+        UCExecChecker: ['exec'],
+        UCInputFilesProcessor: ['exec'],
+        UCInputValidator: ['exec'],
+        UCOutputFilesProcessor: ['exec'],
+    },
+    [`${LIB_NAME}/uc-data-store-knex`]: {
+        KnexUCDataStore: [
+            'clear',
+            'destroy',
+            'exists',
+            'init',
+            'initSync',
+            'read',
+            'readProjection',
+            'startTx',
+            'supportedSpecificBindings',
+            'testKey',
+            'write',
+            'writeBulk',
+            'writeProjection',
+        ],
+    },
+};
+export class InstrumentationOTL extends InstrumentationBase {
+    constructor(config) {
+        super(NAME, LIB_VERSION, config);
+    }
+    init() {
+        const namespaces = Object.keys(TRACABLES);
+        const defs = namespaces.map((namespace) => new InstrumentationNodeModuleDefinition(this.moduleName(namespace, this._config.libPath), [LIB_MIN_VERSION], (moduleExports) => this.wrapAll(moduleExports, namespace), (moduleExports) => this.unwrapAll(moduleExports, namespace)));
+        return defs;
+    }
+    moduleName(namespace, libPath) {
+        if (!libPath) {
+            return namespace; // e.g. libmodulor, libmodulor/uc-data-store-knex
+        }
+        if (!namespace.includes('/')) {
+            return libPath; // ../../../index.js
+        }
+        const moduleName = namespace.split('/')[1];
+        return libPath.replace('.js', `.${moduleName}.js`); // e.g. ../../../index.uc-data-store-knex.js
+    }
+    patchMethod(namespace, className, methodName) {
+        return (original) => {
+            const tracer = this.tracer;
+            const spanName = `${className}.${methodName}`;
+            // biome-ignore lint/suspicious/noExplicitAny: can be anything
+            return function patched(...args) {
+                const span = tracer.startSpan(spanName, {
+                    attributes: {
+                        'scope.name': namespace,
+                    },
+                });
+                const ctx = trace.setSpan(context.active(), span);
+                return context.with(ctx, async () => {
+                    try {
+                        const res = await original.apply(this, args);
+                        span.setStatus({
+                            code: SpanStatusCode.OK,
+                        });
+                        return res;
+                    }
+                    catch (err) {
+                        span.recordException(err);
+                        span.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: err.message,
+                        });
+                        throw err;
+                    }
+                    finally {
+                        span.end();
+                    }
+                });
+            };
+        };
+    }
+    unwrapAll(moduleExports, namespace) {
+        // biome-ignore lint/style/noNonNullAssertion: we want it
+        const entries = Object.entries(TRACABLES[namespace]);
+        for (const [className, methodNames] of entries) {
+            for (const methodName of methodNames) {
+                // biome-ignore lint/style/noNonNullAssertion: we want it
+                this._unwrap(moduleExports[className].prototype, methodName);
+            }
+        }
+        return moduleExports;
+    }
+    wrapAll(moduleExports, namespace) {
+        // biome-ignore lint/style/noNonNullAssertion: we want it
+        const entries = Object.entries(TRACABLES[namespace]);
+        for (const [className, methodNames] of entries) {
+            for (const methodName of methodNames) {
+                this._wrap(
+                // biome-ignore lint/style/noNonNullAssertion: we want it
+                moduleExports[className].prototype, methodName, this.patchMethod(namespace, className, methodName).bind(this));
+            }
+        }
+        return moduleExports;
+    }
+}

package/dist/esm/products/Helper/i18n.d.ts

@@ -105,5 +105,7 @@ export declare const I18n: {
         uc_i_submit_idle: string;
         uc_i_submit_initializing: string;
         uc_i_submit_submitting: string;
+        res_200: string;
+        res_204: string;
     };
 };

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

@@ -1,7 +1,7 @@
 import type { Password, UIntQuantity, UUID } from '../dt/index.js';
 import type { Clearable } from '../utils/index.js';
 import type { BufferManagerBase64String } from './BufferManager.js';
-export type CryptoManagerBinaryToTextEncoding = 'hex';
+export type CryptoManagerBinaryToTextEncoding = 'base64' | 'base64url' | 'hex';
 export type CryptoManagerHash = string;
 export type CryptoManagerHashAlgorithm = 'sha1' | 'sha256' | 'sha512';
 export type CryptoManagerHMACKey = string;

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

@@ -12,8 +12,9 @@ export interface HTTPAPICallerHeaders {
     'Content-Type'?: HTTPContentType;
     Cookie?: string;
 }
+export type HTTPAPICallerAuthorizationHeaderPrefix = 'AWS4-HMAC-SHA256' | 'Basic' | 'Bearer' | 'JWT' | 'OAuth';
 export interface HTTPAPICallerAuthorizationHeader {
-    prefix?: 'AWS4-HMAC-SHA256' | 'Basic' | 'Bearer' | 'JWT' | 'OAuth';
+    prefix?: HTTPAPICallerAuthorizationHeaderPrefix;
     value: ApiKey | JWT | Password;
 }
 export interface HTTPAPICallerBasicAuth {

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

@@ -34,10 +34,10 @@ let JoseJWTManager = class JoseJWTManager {
         };
     }
     async decode(value, opts) {
-        const { alg } = decodeProtectedHeader(value);
-        assertIsDefined(alg, 'alg');
-        const secret = opts?.secret || this.s().jwt_manager_secret;
         try {
+            const { alg } = decodeProtectedHeader(value);
+            assertIsDefined(alg, 'alg');
+            const secret = opts?.secret || this.s().jwt_manager_secret;
             if (alg.startsWith('HS')) {
                 return (await jwtVerify(value, new TextEncoder().encode(secret))).payload;
             }
@@ -51,8 +51,13 @@ let JoseJWTManager = class JoseJWTManager {
             if (err instanceof JWSSignatureVerificationFailed) {
                 throw new UnauthorizedError();
             }
+            // See node_modules/jose/dist/webapi/util/decode_protected_header.js
+            if (err instanceof TypeError &&
+                err.message.toLowerCase().includes('invalid token')) {
+                throw new UnauthorizedError();
+            }
         }
-        throw new Error(`Unsupported alg ${alg}`);
+        throw new UnauthorizedError();
     }
     async decodeUnsafe(value) {
         const decoded = decodeJwt(value);

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

@@ -55,13 +55,19 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
         registerAbort?.(() => {
             abortController.abort();
         });
-        const response = await this.httpAPICallExecutor.fn()(url, {
-            agent,
-            body,
-            headers: reqHeaders,
-            method,
-            signal: abortController.signal,
-        });
+        let response;
+        try {
+            response = await this.httpAPICallExecutor.fn()(url, {
+                agent,
+                body,
+                headers: reqHeaders,
+                method,
+                signal: abortController.signal,
+            });
+        }
+        catch (err) {
+            throw new Error('err_unreachable', { cause: err });
+        }
         const { headers, status } = response;
         this.logger.trace('HTTPAPICaller', {
             body,

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

@@ -1,10 +1,11 @@
+import { logDevWarning } from '../../error/index.js';
 const UNSAFE_SETTING = 'UNSAFE_CHANGE_ME';
 export function unsafeDefaultSetting(suffix = '') {
     return `${UNSAFE_SETTING}${suffix}`;
 }
 export function assertSettingNotUnsafe(key, value) {
     if (typeof value === 'string' && value.startsWith(UNSAFE_SETTING)) {
-        throw new Error(`"${key}" still has the unsafe default value. Please change it !`);
+        throw new Error(`"${key}" still has the unsafe default value`);
     }
     if (Array.isArray(value)) {
         for (const v of value) {
@@ -28,12 +29,10 @@ export function checkSettings(settings, throwIfViolations) {
         }
     }
     if (violations.length > 0) {
-        // 1m  : bold ; 33m : yellow/orange ; 0m  : reset
-        const message = `\x1b[1m\x1b[33m[WARNING] THE SETTINGS ARE NOT SAFE (THIS WILL THROW IN PROD) :\n${violations.join('\n')}\x1b[0m`;
+        const message = `Settings contain violations :\n${violations.join('\n')}`;
         if (throwIfViolations) {
             throw new Error(message);
         }
-        // biome-ignore lint/suspicious/noConsole: we want it
-        console.warn(message);
+        logDevWarning(message);
     }
 }

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

@@ -1,6 +1,7 @@
 import type { Hono } from 'hono';
 import type { AppManifest } from '../../app/index.js';
 import type { DirPath, URLPath } from '../../dt/index.js';
+import type { ProductUCsLoaderOutput } from '../../product/index.js';
 import type { Configurable, SettingsManager } from '../../std/index.js';
 import type { UCDataStore, UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
 import type { OpenAPISpec } from '../lib/openapi/types.js';
@@ -28,6 +29,7 @@ export declare class SyncEdgeWorkerHonoServerManager 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;
+    mountMCP(_ucs: ProductUCsLoaderOutput, _at: URLPath): Promise<void>;
     mountOpenAPISpec(_spec: OpenAPISpec, _at: URLPath): Promise<void>;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;

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

@@ -55,6 +55,9 @@ let SyncEdgeWorkerHonoServerManager = class SyncEdgeWorkerHonoServerManager {
     mountSync(appManifest, ucd, contract) {
         mountHandler(contract, this.runtime, buildHandler(appManifest, ucd, contract, this.serverRequestHandler, this.ucManager, (c) => this.beforeExec(c)));
     }
+    async mountMCP(_ucs, _at) {
+        throw new NotImplementedError('mountMCP');
+    }
     async mountOpenAPISpec(_spec, _at) {
         throw new NotImplementedError('mountOpenAPISpec');
     }

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

@@ -1,2 +1,2 @@
-export { TARGETS, type TargetName } from './lib/manifest.js';
+export { TARGET_CAPABILITIES_SAMPLE, TARGETS, type TargetCapabilities, TargetCapability, type TargetDef, type TargetDefSrc, type TargetName, } from './lib/manifest.js';
 export type { OpenAPISpec } from './lib/openapi/types.js';

package/dist/esm/target/index.js

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

package/dist/esm/target/lib/client/AuthDataStore.d.ts

@@ -0,0 +1,5 @@
+import type { JWT } from '../../../dt/index.js';
+export interface AuthDataStore {
+    get(): Promise<JWT | null>;
+    set(jwt: JWT | null): Promise<void>;
+}

package/dist/esm/target/lib/client/impl/InMemoryAuthDataStore.d.ts

@@ -0,0 +1,7 @@
+import type { JWT } from '../../../../dt/index.js';
+import type { AuthDataStore } from '../AuthDataStore.js';
+export declare class InMemoryAuthDataStore implements AuthDataStore {
+    private jwt;
+    get(): Promise<JWT | null>;
+    set(jwt: JWT | null): Promise<void>;
+}

package/dist/esm/target/lib/client/impl/InMemoryAuthDataStore.js

@@ -0,0 +1,20 @@
+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;
+};
+import { injectable } from 'inversify';
+let InMemoryAuthDataStore = class InMemoryAuthDataStore {
+    jwt = null;
+    async get() {
+        return this.jwt;
+    }
+    async set(jwt) {
+        this.jwt = jwt;
+    }
+};
+InMemoryAuthDataStore = __decorate([
+    injectable()
+], InMemoryAuthDataStore);
+export { InMemoryAuthDataStore };

package/dist/esm/target/lib/client/impl/MixedServerClientManager.d.ts

@@ -0,0 +1,15 @@
+import type { ApiKey, JWT, URL } from '../../../../dt/index.js';
+import { SettingsServerClientManager } from '../../../../std/impl/SettingsServerClientManager.js';
+import type { HTTPAPICallerBasicAuth } from '../../../../std/index.js';
+import type { AuthDataStore } from '../AuthDataStore.js';
+import type { ServerClientManager, ServerClientManagerOpts } from '../ServerClientManager.js';
+export declare class MixedServerClientManager implements ServerClientManager {
+    private authDataStore;
+    private settingsServerClientManager;
+    constructor(authDataStore: AuthDataStore, settingsServerClientManager: SettingsServerClientManager);
+    authApiKey(opts?: ServerClientManagerOpts): Promise<ApiKey | null>;
+    authBasic(opts?: ServerClientManagerOpts): Promise<HTTPAPICallerBasicAuth | null>;
+    authJWT(_opts?: ServerClientManagerOpts): Promise<JWT | null>;
+    baseURL(opts?: ServerClientManagerOpts): Promise<URL>;
+    publicApiKey(opts?: ServerClientManagerOpts): Promise<ApiKey | null>;
+}

package/dist/esm/target/lib/client/impl/MixedServerClientManager.js

@@ -0,0 +1,44 @@
+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 { SettingsServerClientManager } from '../../../../std/impl/SettingsServerClientManager.js';
+let MixedServerClientManager = class MixedServerClientManager {
+    authDataStore;
+    settingsServerClientManager;
+    constructor(authDataStore, settingsServerClientManager) {
+        this.authDataStore = authDataStore;
+        this.settingsServerClientManager = settingsServerClientManager;
+    }
+    async authApiKey(opts) {
+        return this.settingsServerClientManager.authApiKey(opts);
+    }
+    async authBasic(opts) {
+        return this.settingsServerClientManager.authBasic(opts);
+    }
+    async authJWT(_opts) {
+        return this.authDataStore.get();
+    }
+    async baseURL(opts) {
+        return this.settingsServerClientManager.baseURL(opts);
+    }
+    async publicApiKey(opts) {
+        return this.settingsServerClientManager.publicApiKey(opts);
+    }
+};
+MixedServerClientManager = __decorate([
+    injectable(),
+    __param(0, inject('AuthDataStore')),
+    __param(1, inject(SettingsServerClientManager)),
+    __metadata("design:paramtypes", [Object, SettingsServerClientManager])
+], MixedServerClientManager);
+export { MixedServerClientManager };

package/dist/esm/target/lib/json-schema/error.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorMessage, JSONSchemaObject } from '../../../dt/index.js';
+import { type ServerError } from '../../../error/index.js';
+export declare function serverErrorJsonSchema(message?: ErrorMessage): JSONSchemaObject<ServerError>;

package/dist/esm/target/lib/json-schema/error.js

@@ -0,0 +1,14 @@
+import { IllegalArgumentError, } from '../../../error/index.js';
+export function serverErrorJsonSchema(message) {
+    return {
+        additionalProperties: false,
+        properties: {
+            message: {
+                examples: [message ?? new IllegalArgumentError().message],
+                type: 'string',
+            },
+        },
+        required: ['message'],
+        type: 'object',
+    };
+}

package/dist/esm/target/lib/json-schema/input.d.ts

@@ -0,0 +1,16 @@
+import type { DataType, JSONSchemaObject, JSONSchemaProperty } from '../../../dt/index.js';
+import { type UC, type UCInput, type UCInputField, type UCInputUnwrapped, type UCOPIBase } from '../../../uc/index.js';
+export interface UCInputFieldJsonSchemaDef<T extends DataType> {
+    /**
+     * Internal types that are not part of the spec
+     */
+    internal?: {
+        required?: boolean;
+    };
+    /**
+     * Fields that are part of the spec
+     */
+    spec?: JSONSchemaProperty<T>;
+}
+export declare function ucifJsonSchemaDef<T extends DataType>(field: UCInputField<T>): UCInputFieldJsonSchemaDef<T>;
+export declare function ucInputJsonSchema<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): JSONSchemaObject<UCInputUnwrapped<I>>;

package/dist/esm/target/lib/json-schema/input.js

@@ -0,0 +1,67 @@
+import { ucifExamples, ucifIsMandatory, ucifRepeatability, } from '../../../uc/index.js';
+export function ucifJsonSchemaDef(field) {
+    const def = {
+        internal: {},
+        spec: { type: 'string' },
+    };
+    if (!def.internal || !def.spec) {
+        // Just a guard to safely type the rest of the function without using !
+        return def;
+    }
+    const { def: fDef } = field;
+    const { type: fType } = fDef;
+    def.internal.required = ucifIsMandatory(fDef);
+    def.spec = fType.jsonSchemaType();
+    if (!def.internal.required && !Array.isArray(def.spec.type)) {
+        def.spec.type = [def.spec.type, 'null'];
+    }
+    const examples = ucifExamples(fDef);
+    if (examples) {
+        def.spec.examples = examples;
+    }
+    const options = fType.getOptions();
+    if (options) {
+        def.spec.enum = options.map((o) => o.value);
+        if (!def.internal.required) {
+            def.spec.enum.push(null);
+        }
+    }
+    const [isRepeatable] = ucifRepeatability(fDef);
+    if (isRepeatable) {
+        def.spec = {
+            items: def.spec,
+            type: def.internal.required ? 'array' : ['array', 'null'],
+        };
+        if (fDef.cardinality?.max !== undefined) {
+            def.spec.maxItems = fDef.cardinality?.max;
+        }
+        if (fDef.cardinality?.min !== undefined) {
+            def.spec.minItems = fDef.cardinality?.min;
+        }
+    }
+    return def;
+}
+export function ucInputJsonSchema(uc) {
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    for (const f of uc.inputFields) {
+        const { key } = f;
+        const { internal, spec } = ucifJsonSchemaDef(f);
+        if (!spec) {
+            continue;
+        }
+        const k = key;
+        res.properties[k] = spec;
+        if (!internal?.required) {
+            continue;
+        }
+        if (!res.required) {
+            res.required = [];
+        }
+        res.required.push(k);
+    }
+    return res;
+}

package/dist/esm/target/lib/json-schema/output.d.ts

@@ -0,0 +1,19 @@
+import type { DataType, JSONSchemaObject, JSONSchemaProperty } from '../../../dt/index.js';
+import { type UC, type UCInput, type UCOPIBase, type UCOutput, UCOutputField, type UCOutputPart, type UCOutputPartDef } from '../../../uc/index.js';
+export interface UCOutputFieldJsonSchemaDef<T extends DataType> {
+    /**
+     * Internal types that are not part of the spec
+     */
+    internal?: {
+        required?: boolean;
+    };
+    /**
+     * Fields that are part of the spec
+     */
+    spec?: JSONSchemaProperty<T>;
+}
+export declare function ucofJsonSchemaDef<OPI extends UCOPIBase, T extends DataType>(field: UCOutputField<OPI, T>): UCOutputFieldJsonSchemaDef<T>;
+export declare function ucOPIJsonSchema<OPI extends UCOPIBase>(part: UCOutputPartDef<NonNullable<OPI>>): JSONSchemaObject<OPI>;
+export declare function ucOutputPartJsonSchema<OPI extends UCOPIBase>(part: UCOutputPartDef<NonNullable<OPI>>): JSONSchemaObject<UCOutputPart<OPI>>;
+export declare function ucOutputPartPaginationJsonSchema<OPI extends UCOPIBase>(): JSONSchemaObject<NonNullable<UCOutputPart<OPI>['pagination']>>;
+export declare function ucOutputJsonSchema<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): JSONSchemaObject<UCOutput<OPI0, OPI1>> | null;

package/dist/esm/target/lib/json-schema/output.js

@@ -0,0 +1,128 @@
+import { UCOPIBaseDefFields, UCOutputField, ucofExamples, ucofIsMandatory, ucofRepeatability, } from '../../../uc/index.js';
+export function ucofJsonSchemaDef(field) {
+    const def = {
+        internal: {},
+        spec: { type: 'string' },
+    };
+    if (!def.internal || !def.spec) {
+        // Just a guard to safely type the rest of the function without using !
+        return def;
+    }
+    const { def: fDef } = field;
+    const { type: fType } = fDef;
+    def.internal.required = ucofIsMandatory(fDef);
+    def.spec = fType.jsonSchemaType();
+    if (!def.internal.required && !Array.isArray(def.spec.type)) {
+        def.spec.type = [def.spec.type, 'null'];
+    }
+    const examples = ucofExamples(fDef);
+    if (examples) {
+        def.spec.examples = examples;
+    }
+    const options = fType.getOptions();
+    if (options) {
+        def.spec.enum = options.map((o) => o.value);
+        if (!def.internal.required) {
+            def.spec.enum.push(null);
+        }
+    }
+    const [isRepeatable] = ucofRepeatability(fDef);
+    if (isRepeatable) {
+        def.spec = {
+            items: def.spec,
+            type: def.internal.required ? 'array' : ['array', 'null'],
+        };
+        if (fDef.cardinality?.max !== undefined) {
+            def.spec.maxItems = fDef.cardinality?.max;
+        }
+        if (fDef.cardinality?.min !== undefined) {
+            def.spec.minItems = fDef.cardinality?.min;
+        }
+    }
+    return def;
+}
+export function ucOPIJsonSchema(part) {
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    const allFields = { ...UCOPIBaseDefFields, ...part.fields };
+    for (const entry of Object.entries(allFields)) {
+        const key = entry[0];
+        const fDef = entry[1];
+        const f = new UCOutputField(key, fDef);
+        const { internal, spec } = ucofJsonSchemaDef(f);
+        if (!spec) {
+            continue;
+        }
+        const k = key;
+        res.properties[k] = spec;
+        if (!internal?.required) {
+            continue;
+        }
+        if (!res.required) {
+            res.required = [];
+        }
+        res.required.push(k);
+    }
+    return res;
+}
+export function ucOutputPartJsonSchema(part) {
+    return {
+        additionalProperties: false,
+        properties: {
+            items: {
+                items: ucOPIJsonSchema(part),
+                type: 'array',
+            },
+            pagination: ucOutputPartPaginationJsonSchema(),
+            total: { examples: [1], type: 'integer' },
+        },
+        required: ['items', 'total'],
+        type: 'object',
+    };
+}
+export function ucOutputPartPaginationJsonSchema() {
+    return {
+        additionalProperties: false,
+        properties: {
+            id: { format: 'uuid', type: 'string' },
+            limit: { type: 'integer' },
+            offset: { type: 'integer' },
+            q: { type: 'string' },
+        },
+        type: 'object',
+    };
+}
+export function ucOutputJsonSchema(uc) {
+    if (!uc.hasOutputParts()) {
+        return null;
+    }
+    const res = {
+        additionalProperties: false,
+        properties: {},
+        type: 'object',
+    };
+    const part0 = uc.def.io.o?.parts?._0;
+    if (!part0) {
+        return null;
+    }
+    res.properties.parts = {
+        additionalProperties: false,
+        properties: {
+            _0: ucOutputPartJsonSchema(part0),
+        },
+        required: ['_0'],
+        type: 'object',
+    };
+    const part1 = uc.def.io.o?.parts?._1;
+    if (!part1) {
+        return res;
+    }
+    res.properties.parts.properties = {
+        _1: ucOutputPartJsonSchema(part1),
+    };
+    res.properties.parts.required?.push('_1');
+    return res;
+}