libmodulor 0.20.0 → 0.22.0

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

@@ -3,14 +3,60 @@ 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';
+import { fmtSingleDataMsg, fmtSSEError, fromFormData, isError, SSE_HEADERS, } from '../../../utils/index.js';
 export function buildHandler(appManifest, ucd, contract, serverRequestHandler, ucManager, beforeExec) {
     const { envelope } = contract;
     const handler = async (c) => {
         await beforeExec?.(c);
+        const transportType = ucd.ext?.http?.transportType ?? 'standard';
+        let execOpts;
+        let stream;
+        let controller;
+        switch (transportType) {
+            case 'standard':
+                // Nothing to do
+                break;
+            case 'stream': {
+                stream = new ReadableStream({
+                    start: (ctrl) => {
+                        controller = ctrl;
+                        let closed = false;
+                        const close = () => {
+                            if (closed) {
+                                return;
+                            }
+                            ctrl.close();
+                            closed = true;
+                        };
+                        execOpts = {
+                            stream: {
+                                onClose: async () => { },
+                                onData: async (output) => {
+                                    if (!output || closed) {
+                                        return;
+                                    }
+                                    ctrl.enqueue(fmtSingleDataMsg(output));
+                                },
+                                onDone: async () => {
+                                    close();
+                                },
+                            },
+                        };
+                        c.req.raw.signal.addEventListener('abort', async () => {
+                            close();
+                            await execOpts?.stream?.onClose();
+                        });
+                    },
+                });
+                break;
+            }
+            default:
+                ((_) => { })(transportType);
+        }
         const { body, status } = await serverRequestHandler.exec({
             appManifest,
             envelope,
+            execOpts,
             req: toReq(c),
             res: toRes(c),
             ucd,
@@ -19,6 +65,23 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
         if (!body) {
             return c.newResponse(null, status);
         }
+        switch (transportType) {
+            case 'standard':
+                return c.json(body, status);
+            case 'stream': {
+                if (isError(status)) {
+                    controller?.enqueue(fmtSSEError({
+                        message: body.message,
+                        status,
+                    }));
+                }
+                return new Response(stream, {
+                    headers: SSE_HEADERS,
+                });
+            }
+            default:
+                ((_) => { })(transportType);
+        }
         return c.json(body, status);
     };
     return handler;
@@ -50,7 +113,7 @@ export function toReq(c) {
     return {
         bodyFromFormData: async () => fromFormData(await c.req.formData()),
         bodyFromJSON: () => c.req.json(),
-        bodyFromQueryParams: async () => c.req.queries(),
+        bodyFromQueryParams: async () => c.req.query(),
         bodyRaw: c.req.raw,
         cookie: async (name) => getCookie(c, name),
         header: async (name) => c.req.header(name),

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

@@ -125,6 +125,7 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
                 def: ucd,
             });
             if (args) {
+                // biome-ignore lint/suspicious/noExplicitAny: can be anything
                 uc.fill(args);
             }
             const confirmed = await this.ucManager.confirmClient(uc);

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

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

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

@@ -3,10 +3,10 @@ import { View } from 'react-native';
 import { useStyleContext } from '../lib/react/StyleContextProvider.js';
 import { UCFormField } from './UCFormField.js';
 import { UCFormSubmitControl } from './UCFormSubmitControl.js';
-export function UCForm({ disabled, execState, onChange, onSubmit, uc, }) {
+export function UCForm({ disabled, execState, onSubmit, uc, }) {
     const { form } = useStyleContext();
     const onPress = async () => {
         await onSubmit();
     };
-    return (_jsxs(View, { style: form?.style, children: [uc.inputFieldsForForm().map((f) => (_jsx(UCFormField, { disabled: disabled, execState: execState, f: f, onChange: onChange }, f.key))), _jsx(UCFormSubmitControl, { disabled: disabled, execState: execState, onPress: onPress, uc: uc })] }));
+    return (_jsxs(View, { style: form?.style, children: [uc.inputFieldsForForm().map((f) => (_jsx(UCFormField, { disabled: disabled, execState: execState, f: f }, f.key))), _jsx(UCFormSubmitControl, { disabled: disabled, execState: execState, onPress: onPress, uc: uc })] }));
 }

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

@@ -1,4 +1,4 @@
 import { type ReactElement } from 'react';
 import type { DataType } from '../../dt/index.js';
 import { type UCFormFieldProps } from '../lib/react/form.js';
-export declare function UCFormField<T extends DataType>({ disabled, execState, f, onChange: onChangeBase, only, }: UCFormFieldProps<T>): ReactElement;
+export declare function UCFormField<T extends DataType>({ disabled, execState, f, only, }: UCFormFieldProps<T>): ReactElement;

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

@@ -8,13 +8,12 @@ import { UCFormFieldControl } from './UCFormFieldControl.js';
 import { UCFormFieldDesc } from './UCFormFieldDesc.js';
 import { UCFormFieldErr } from './UCFormFieldErr.js';
 import { UCFormFieldLabel } from './UCFormFieldLabel.js';
-export function UCFormField({ disabled, execState, f, onChange: onChangeBase, only, }) {
+export function UCFormField({ disabled, execState, f, only, }) {
     const { i18nManager } = useDIContext();
     const { formField } = useStyleContext();
     const [errMsg, setErrMsg] = useState(null);
-    const onChange = (f, op, v) => {
-        setErrMsg(validateFormField(i18nManager, f, v));
-        onChangeBase(f, op, v);
+    const onChange = () => {
+        setErrMsg(validateFormField(i18nManager, f));
     };
     const elements = only ?? UC_FORM_FIELD_ELEMENTS;
     return (_jsxs(View, { style: formField?.style, children: [elements.includes('label') && _jsx(UCFormFieldLabel, { f: f }), elements.includes('control') && (_jsx(UCFormFieldControl, { disabled: disabled, execState: execState, f: f, onChange: onChange })), elements.includes('err') && errMsg && (_jsx(UCFormFieldErr, { errMsg: errMsg })), elements.includes('desc') && _jsx(UCFormFieldDesc, { f: f })] }));

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

@@ -2,7 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { FlatList, Pressable, StyleSheet, Switch, Text, TextInput, } from 'react-native';
 import { TBoolean } from '../../dt/index.js';
-import { UCInputFieldChangeOperator, ucifRepeatability, } from '../../uc/index.js';
+import { ucifRepeatability } from '../../uc/index.js';
 import { isBlank } from '../../utils/index.js';
 import { styleDef, useStyleContext, } from '../lib/react/StyleContextProvider.js';
 import { rnInputDef } from '../lib/rn/input.js';
@@ -31,24 +31,30 @@ export function UCFormFieldControl({ disabled, errMsg = null, execState, f, onCh
             const valueArr = value
                 .split(MULTIPLE_VALUES_SEPARATOR)
                 .map((v) => v.trim());
-            onChangeBase(f, UCInputFieldChangeOperator.SET, valueArr);
+            f.setVal(valueArr);
+            onChangeBase();
+            setInternalValue(valueArr);
         }
         else {
-            onChangeBase(f, UCInputFieldChangeOperator.SET, value);
+            f.setVal(value);
+            onChangeBase();
+            setInternalValue(value);
         }
-        setInternalValue(value);
     };
     const onSelect = (value) => {
         if (internalValue === value) {
-            onChangeBase(f, UCInputFieldChangeOperator.RESET, null);
+            f.clear();
+            onChangeBase();
             setInternalValue(null);
             return;
         }
-        onChangeBase(f, UCInputFieldChangeOperator.SET, value);
+        f.setVal(value);
+        onChangeBase();
         setInternalValue(value);
     };
     const onValueChange = (value) => {
-        onChangeBase(f, UCInputFieldChangeOperator.SET, value);
+        f.setVal(value);
+        onChangeBase();
         setInternalValue(value);
     };
     const attrs = rnInputDef(f, disabled, errMsg);

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

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

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

@@ -3,7 +3,7 @@ import { useRef } from 'react';
 import { useStyleContext } from '../lib/react/StyleContextProvider.js';
 import { UCFormField } from './UCFormField.js';
 import { UCFormSubmitControl } from './UCFormSubmitControl.js';
-export function UCForm({ clearAfterExec, disabled, execState, onChange, onSubmit: onSubmitBase, uc, }) {
+export function UCForm({ clearAfterExec, disabled, execState, onSubmit: onSubmitBase, uc, }) {
     const { form } = useStyleContext();
     const formRef = useRef(null);
     const onSubmit = async (e) => {
@@ -13,5 +13,5 @@ export function UCForm({ clearAfterExec, disabled, execState, onChange, onSubmit
             formRef.current?.reset();
         }
     };
-    return (_jsxs("form", { className: form?.className, onSubmit: onSubmit, ref: formRef, style: form?.style, children: [uc.inputFieldsForForm().map((f) => (_jsx(UCFormField, { disabled: disabled, execState: execState, f: f, onChange: onChange }, f.key))), _jsx(UCFormSubmitControl, { disabled: disabled, execState: execState, uc: uc })] }));
+    return (_jsxs("form", { className: form?.className, onSubmit: onSubmit, ref: formRef, style: form?.style, children: [uc.inputFieldsForForm().map((f) => (_jsx(UCFormField, { disabled: disabled, execState: execState, f: f }, f.key))), _jsx(UCFormSubmitControl, { disabled: disabled, execState: execState, uc: uc })] }));
 }

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

@@ -1,4 +1,4 @@
 import { type ReactElement } from 'react';
 import type { DataType } from '../../dt/index.js';
 import { type UCFormFieldProps } from '../lib/react/form.js';
-export declare function UCFormField<T extends DataType>({ disabled, execState, f, onChange: onChangeBase, only, }: UCFormFieldProps<T>): ReactElement;
+export declare function UCFormField<T extends DataType>({ disabled, execState, f, only, }: UCFormFieldProps<T>): ReactElement;

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

@@ -7,13 +7,12 @@ import { UCFormFieldControl } from './UCFormFieldControl.js';
 import { UCFormFieldDesc } from './UCFormFieldDesc.js';
 import { UCFormFieldErr } from './UCFormFieldErr.js';
 import { UCFormFieldLabel } from './UCFormFieldLabel.js';
-export function UCFormField({ disabled, execState, f, onChange: onChangeBase, only, }) {
+export function UCFormField({ disabled, execState, f, only, }) {
     const { i18nManager } = useDIContext();
     const { formField } = useStyleContext();
     const [errMsg, setErrMsg] = useState(null);
-    const onChange = (f, op, v) => {
-        setErrMsg(validateFormField(i18nManager, f, v));
-        onChangeBase(f, op, v);
+    const onChange = () => {
+        setErrMsg(validateFormField(i18nManager, f));
     };
     const elements = only ?? UC_FORM_FIELD_ELEMENTS;
     return (_jsxs("div", { className: formField?.className, style: formField?.style, children: [elements.includes('label') && _jsx(UCFormFieldLabel, { f: f }), elements.includes('control') && (_jsx(UCFormFieldControl, { disabled: disabled, execState: execState, f: f, onChange: onChange })), elements.includes('err') && errMsg && (_jsx(UCFormFieldErr, { errMsg: errMsg })), elements.includes('desc') && _jsx(UCFormFieldDesc, { f: f })] }));

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { TBoolean } from '../../dt/index.js';
-import { UCInputFieldChangeOperator, ucifRepeatability, } from '../../uc/index.js';
+import { ucifRepeatability } from '../../uc/index.js';
 import { styleDef, useStyleContext, } from '../lib/react/StyleContextProvider.js';
 import { htmlInputDef } from '../lib/web/input.js';
 const CHECKED_FIELD_TYPES = ['checkbox', 'radio'];
@@ -27,7 +27,8 @@ export function UCFormFieldControl({ disabled, errMsg = null, execState, f, onCh
         if (target.localName === 'select' && !value) {
             // Prevent the value from being '' when we set/unset the select
             // Otherwise it sets '' as value and prevents the form for being valid
-            onChangeBase(f, UCInputFieldChangeOperator.RESET, value);
+            f.clear();
+            onChangeBase();
             return;
         }
         if (CHECKED_FIELD_TYPES.includes(type) && 'checked' in target) {
@@ -41,10 +42,12 @@ export function UCFormFieldControl({ disabled, errMsg = null, execState, f, onCh
             const valueArr = value
                 .split(MULTIPLE_VALUES_SEPARATOR)
                 .map((v) => v.trim());
-            onChangeBase(f, UCInputFieldChangeOperator.SET, valueArr);
+            f.setVal(valueArr);
+            onChangeBase();
         }
         else {
-            onChangeBase(f, UCInputFieldChangeOperator.SET, value);
+            f.setVal(value);
+            onChangeBase();
         }
     };
     const defaultChecked = attrs.internal?.checked;

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

@@ -62,7 +62,7 @@ export declare class AppTester {
     checkUCDSources(): Promise<void>;
     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>>;
+    execMonkeyTest<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>, input: NonNullable<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;

package/dist/esm/testing/AppTester.js

@@ -13,7 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { inject, injectable } from 'inversify';
 import { I18nEN } from '../i18n/locales/en.js';
 import { I18nFR } from '../i18n/locales/fr.js';
-import { FAKE_USER_ADMIN, UCBuilder, UCInputFieldChangeOperator, ucHTTPContract, } from '../uc/index.js';
+import { FAKE_USER_ADMIN, UCBuilder, ucHTTPContract, } from '../uc/index.js';
 // We inject directly the implementation because we'll generate all the reports and not only the one that is bound to the interface.
 // We can plan a setting à la Vitest where we specify the types of reports to generate though.
 import { SimpleHTMLAppTestReportEmitter } from './impl/SimpleHTMLAppTestReportEmitter.js';
@@ -137,7 +137,8 @@ let AppTester = class AppTester {
                 if (inputOverride) {
                     const inputOverrides = inputOverride(output);
                     for (const [k, v] of Object.entries(inputOverrides)) {
-                        uc.inputField(k).setValue(UCInputFieldChangeOperator.SET, v);
+                        // @ts-expect-error
+                        uc.inputField(k).setVal(v);
                     }
                 }
             };

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

@@ -140,7 +140,7 @@ const template = (appPath, testResults, testSummary) => `<!DOCTYPE html>
                 const search = new URLSearchParams(window.location.search);
                 const status = search.get('status');
                 if (status) {
-                    document.querySelectorAll(\`table tbody tr:not(.\${status\})\`).forEach((n) => n.remove());
+                    document.querySelectorAll(\`table tbody tr:not(.\${status})\`).forEach((n) => n.remove());
                 }
             </script>
         </table>

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

@@ -92,9 +92,9 @@ let TypeScriptLibUCDefASTParser = class TypeScriptLibUCDefASTParser {
                 target)],
         };
         this.compilerOptions.incremental = false; // Otherwise it triggers the following error : Option '--incremental' can only be specified using tsconfig, emitting to single file or when option '--tsBuildInfoFile' is specified.
-        // @ts-ignore
+        // @ts-expect-error
         this.compilerOptions.jsx = undefined; // Otherwise it triggers the following error since TS 5.5 : jsx is a string value; tsconfig JSON must be parsed with parseJsonSourceFileConfigFileContent or getParsedCommandLineOfConfigFile before passing to createProgram
-        // @ts-ignore
+        // @ts-expect-error
         this.compilerOptions.lib = undefined; // Otherwise it triggers errors saying it does not find them
     }
     getTypeFields(node) {

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

@@ -186,7 +186,7 @@ describe('Run', async () => {
                         expect(out).toSatisfy(assertion);
                     } else {
                         expect({ out, sideEffects }).toMatchSnapshot(
-                            \`hash = \${hash\}\`,
+                            \`hash = \${hash}\`,
                         );
                     }
                 },
@@ -209,7 +209,10 @@ describe('Run', async () => {
                     }
 
                     public async run(_m: Model, _r: RealSystem): Promise<void> {
-                        const out = await runner.execMonkeyTest(ucd, this.input);
+                        const out = await runner.execMonkeyTest(
+                            ucd,
+                            this.input,
+                        );
 
                         if (out.err !== null) {
                             if (!(out.err instanceof CustomError)) {
@@ -220,7 +223,7 @@ describe('Run', async () => {
                     }
 
                     public toString(): string {
-                        return \`\${ucd.metadata.name\}(\${JSON.stringify(this.input)\})\`;
+                        return \`\${ucd.metadata.name}(\${JSON.stringify(this.input)})\`;
                     }
                 }
 

package/dist/esm/testing/uc-input.js

@@ -1,5 +1,5 @@
 import { TFile } from '../dt/index.js';
-import { UCInputFieldChangeOperator, ucifIsMandatory, ucifMustBeFilledManually, ucifRepeatability, } from '../uc/index.js';
+import { ucifIsMandatory, ucifMustBeFilledManually, ucifRepeatability, } from '../uc/index.js';
 export const DEFAULT_UC_INPUT_FILLERS = [
     'ALL_WITH_EXAMPLES',
     'ONLY_MANDATORY_WITH_EXAMPLES',
@@ -36,19 +36,20 @@ export function onlySetProgrammaticallyWithExamples(uc) {
 // biome-ignore lint/suspicious/noExplicitAny: can be anything
 function fillWithExample(f) {
     const { type } = f.def;
-    let val = type.getExamples()?.[0] ?? type.example();
     if (type instanceof TFile) {
-        const file = val;
+        const example = type.getExamples()?.[0] ?? type.example();
         // TODO : Consider building a real file with real data (e.g. image, pdf, txt, etc.)
-        val = new File(['01010101010101010101010101010101'], file.path, {
-            type: file.type,
+        const val = new File(['01010101010101010101010101010101'], example.path, {
+            type: example.type,
         });
+        const [isRepeatable] = ucifRepeatability(f.def);
+        if (isRepeatable) {
+            f.addVal(val);
+        }
+        else {
+            f.setVal(val);
+        }
+        return;
     }
-    const [isRepeatable] = ucifRepeatability(f.def);
-    if (isRepeatable) {
-        f.setValue(UCInputFieldChangeOperator.ADD, val);
-    }
-    else {
-        f.setValue(UCInputFieldChangeOperator.SET, val);
-    }
+    f.fillWithExample();
 }

package/dist/esm/testing/workers/UCExecutor.js

@@ -13,6 +13,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var UCExecutor_1;
 import { inject, injectable } from 'inversify';
 import { rInput, UCBuilder, } from '../../uc/index.js';
+const ERR_CLIENT_EXPECTED_UCOR = (name) => `${name} client is expected to return an ucor`;
 const ERR_CLIENT_EXPECTED_OUTPUT = (name) => `${name} client is expected to return an output but returned nothing`;
 const ERR_CLIENT_UNEXPECTED_OUTPUT = (name) => `${name} client is expected to return nothing but returned an output`;
 let UCExecutor = class UCExecutor {
@@ -70,7 +71,44 @@ let UCExecutor = class UCExecutor {
         out.io.i = input;
         out.hash = this.cryptoManager.hash(UCExecutor_1.HASH_ALG, [name, JSON.stringify(args), JSON.stringify(input)].join(UCExecutor_1.HASH_SEP), UCExecutor_1.HASH_BTT_ENCODING);
         try {
-            const ucor = await this.ucManager.execClient(uc);
+            let ucor;
+            const transportType = ucd.ext?.http?.transportType ?? 'standard';
+            switch (transportType) {
+                case 'standard':
+                    ucor = await this.ucManager.execClient(uc);
+                    break;
+                case 'stream': {
+                    try {
+                        let abort;
+                        await this.ucManager.execClient(uc, {
+                            registerAbort: (func) => {
+                                abort = func;
+                            },
+                            stream: {
+                                onClose: async () => { },
+                                onData: async (ucor2) => {
+                                    if (!ucor) {
+                                        ucor = ucor2;
+                                        abort();
+                                    }
+                                },
+                                onDone: async () => { },
+                            },
+                        });
+                    }
+                    catch (err) {
+                        if (err.name !== 'AbortError') {
+                            throw err;
+                        }
+                    }
+                    break;
+                }
+                default:
+                    ((_) => { })(transportType);
+            }
+            if (!ucor) {
+                throw new Error(ERR_CLIENT_EXPECTED_UCOR(name));
+            }
             const output = ucor.output();
             if (uc.hasOutputParts() && !output) {
                 throw new Error(ERR_CLIENT_EXPECTED_OUTPUT(name));
@@ -92,13 +130,13 @@ let UCExecutor = class UCExecutor {
             if (Array.isArray(v)) {
                 v.forEach((vv, idx) => {
                     if (vv instanceof File) {
-                        // @ts-ignore
+                        // @ts-expect-error
                         input[k][idx] = this.derandomizeInputFile(vv);
                     }
                 });
             }
             else if (v instanceof File) {
-                // @ts-ignore
+                // @ts-expect-error
                 input[k] = this.derandomizeInputFile(v);
             }
         }

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

@@ -2,7 +2,7 @@ import type { AppManifest } from '../app/index.js';
 import { type DataType, Validation } from '../dt/index.js';
 import type { UCAuth } from './auth.js';
 import type { UCDef, UCFieldKey } from './def.js';
-import type { UCInput } from './input.js';
+import type { UCInput, UCInputKey, UCInputKeyDataType, UCInputPartial } from './input.js';
 import type { UCOPIBase } from './opi.js';
 import { UCInputField } from './UCInputField.js';
 import type { reqVal0, rVal0, rValArr } from './utils/rVal.js';
@@ -16,15 +16,15 @@ export declare class UC<I extends UCInput | undefined = undefined, OPI0 extends
     appManifest: AppManifest;
     def: UCDef<I, OPI0, OPI1>;
     auth: UCAuth | null;
-    inputFields: UCInputField<any>[];
+    inputFields: UCInputField<DataType>[];
     constructor(appManifest: AppManifest, def: UCDef<I, OPI0, OPI1>, auth: UCAuth | null);
     clear(): void;
     clearSensitiveInputFields(): void;
-    fill(input: Partial<I>): this;
+    fill(input: UCInputPartial<I>): this;
     hasInputField(key: UCFieldKey): boolean;
     hasMediaInInput(): boolean;
     hasOutputParts(): boolean;
-    inputField<T extends DataType>(key: keyof NonNullable<I>): UCInputField<T>;
+    inputField<K extends UCInputKey<I>>(key: K): UCInputField<UCInputKeyDataType<I, K>>;
     inputFieldsForForm(): UCInputField<any>[];
     inputFieldsOrdered(): UCInputField<any>[];
     inputFieldsInsensitive(): UCInputField<any>[];
@@ -32,8 +32,8 @@ export declare class UC<I extends UCInput | undefined = undefined, OPI0 extends
     needsInputFilling(): boolean;
     needsOutputDisplay(): boolean;
     operatesOnAggregate(): boolean;
-    rVal0<T extends DataType>(key: keyof I): ReturnType<typeof rVal0<T>>;
-    reqVal0<T extends DataType>(key: keyof I): ReturnType<typeof reqVal0<T>>;
-    rValArr<T extends DataType>(key: keyof I): ReturnType<typeof rValArr<T>>;
+    rVal0<K extends UCInputKey<I>>(key: K): ReturnType<typeof rVal0<UCInputKeyDataType<I, K>>>;
+    reqVal0<K extends UCInputKey<I>>(key: K): ReturnType<typeof reqVal0<UCInputKeyDataType<I, K>>>;
+    rValArr<K extends UCInputKey<I>>(key: K): ReturnType<typeof rValArr<UCInputKeyDataType<I, K>>>;
     validate(): [UCInputField<any> | null, Validation] | null;
 }

package/dist/esm/uc/UC.js

@@ -1,6 +1,6 @@
 import { TFile, Validation } from '../dt/index.js';
 import { isBlank } from '../utils/index.js';
-import { UCInputFieldChangeOperator, ucifIsMandatory, ucifIsSensitive, ucifMustBeFilledManually, } from './input-field.js';
+import { ucifIsMandatory, ucifIsSensitive, ucifMustBeFilledManually, } from './input-field.js';
 import { AggregateInputDef } from './io/input/AggregateInput.js';
 import { ListInputDef } from './io/input/ListInput.js';
 import { UCInputField } from './UCInputField.js';
@@ -8,7 +8,6 @@ export class UC {
     appManifest;
     def;
     auth;
-    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     inputFields;
     constructor(appManifest, def, auth) {
         this.appManifest = appManifest;
@@ -40,7 +39,8 @@ export class UC {
     }
     fill(input) {
         for (const f of this.inputFields) {
-            f.setValue(UCInputFieldChangeOperator.SET, input[f.key]);
+            const val = input[f.key];
+            f.setVal(val);
         }
         return this;
     }
@@ -58,6 +58,7 @@ export class UC {
         if (!field) {
             throw new Error(`Input field ${key.toString()} does not exist`);
         }
+        // @ts-expect-error
         return field;
     }
     // biome-ignore lint/suspicious/noExplicitAny: can be anything

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

@@ -1,6 +1,6 @@
 import { type DataType, Validation } from '../dt/index.js';
 import type { UCFieldKey, UCWording } from './def.js';
-import { UCInputFieldChangeOperator, type UCInputFieldDef, type UCInputFieldValue } from './input-field.js';
+import { type UCInputFieldDef, type UCInputFieldValue } from './input-field.js';
 import { type reqVal0, rVal0, rValArr } from './utils/rVal.js';
 export declare class UCInputField<T extends DataType> {
     key: UCFieldKey;
@@ -13,7 +13,9 @@ export declare class UCInputField<T extends DataType> {
     private dynamicWording;
     private value;
     constructor(key: UCFieldKey, def: UCInputFieldDef<T>);
+    addVal(value: UCInputFieldValue<T>): void;
     clear(): void;
+    fillWithExample(): void;
     getDynamicWording(): Partial<UCWording> | undefined;
     getValue(): UCInputFieldValue<T>;
     /**
@@ -35,14 +37,15 @@ export declare class UCInputField<T extends DataType> {
      */
     reqVal0(): ReturnType<typeof reqVal0<T>>;
     /**
-     * Require the value as an array
+     * Read the value as an array
      *
      * Unlink the standalone {@link rValArr}, it returns the default value in an array if present.
      *
      * @returns
      */
     rValArr(): ReturnType<typeof rValArr<T>>;
-    setValue(op: UCInputFieldChangeOperator, value: UCInputFieldValue<T>): void;
+    rmVal(value: UCInputFieldValue<T>): void;
+    setVal(value: UCInputFieldValue<T>): void;
     updateDef(def: UCInputFieldDef<T>): void;
     updateDynamicWording(dynamicWording: Partial<UCWording> | undefined): void;
     updateType(type: UCInputFieldDef<T>['type']): void;