nesoi 3.0.21 → 3.1.1

package/lib/compiler/typescript/bridge/organize.js

@@ -57,21 +57,25 @@ class TSBridgeOrganize {
     }
     static message(organized, tag, path, node) {
         var _a, _b;
-        const rule = path.match(/template▹0▹return▹([\w|\\.]+)▹rule▹0/);
+        const rule = path.match(/template▹0▹return▹(.+)▹rule▹0/);
         if (rule) {
             const [_, prop] = rule;
+            let path = prop.replace(/▹obj▹0▹/g, '.');
+            path = path.replace(/▹union▹/g, '.');
+            path = path.replace(/▹list▹0/g, '.#');
+            path = path.replace(/▹dict▹0/g, '.#');
             (_a = organized.messages)[tag] ?? (_a[tag] = { rules: {} });
-            (_b = organized.messages[tag].rules)[prop] ?? (_b[prop] = []);
-            organized.messages[tag].rules[prop].push(node);
+            (_b = organized.messages[tag].rules)[path] ?? (_b[path] = []);
+            organized.messages[tag].rules[path].push(node);
             return;
         }
     }
     static inlineMessage(organized, parentTag, path, node) {
-        const message = path.match(/messages▹0▹return▹([\w|\\.]*)▹(.*)/);
+        const message = path.match(/message▹(@|\w+)▹1▹return▹(.*)/);
         if (message) {
             const [_, inlineName, path] = message;
             const parent = dependency_1.$Tag.parseOrFail(parentTag);
-            const msgName = inlineName.length ? `${parent.name}.${inlineName}` : parent.name;
+            const msgName = inlineName === '@' ? parent.name : `${parent.name}.${inlineName}`;
             const msgTag = `${parent.module}::message:${msgName}`;
             const templatePath = `template▹0▹return▹${path}`;
             this.message(organized, msgTag, templatePath, node);

package/lib/compiler/typescript/typescript_compiler.d.ts

@@ -25,9 +25,7 @@ export declare class TypeScriptCompiler {
     /**
      * Extract all import nodes
      */
-    extractImports(filepath: string, $?: {
-        ignore?: string[];
-    }): string[];
+    extractImports(filepath: string): string[];
     query(filepath: string, $: {
         query: string;
         expectedKinds: ts.SyntaxKind[];
@@ -43,11 +41,11 @@ export declare class TypeScriptCompiler {
     getNesoiSymbol(name: string, path: string): ts.Symbol;
     getPropPath(node: ts.PropertyAssignment): string;
     findAllNesoiBuilders(node: ts.Node): Partial<Record<BuilderType, Record<string, ts.Node>>>;
-    findAll(node: ts.Node, predicate: (node: ts.Node) => ts.Node | undefined): ts.Node[];
+    findAll(node: ts.Node, predicate: (node: ts.Node) => ts.Node[] | undefined): ts.Node[];
     private findParent;
     private findInCallChain;
-    private findCallsUntilRoot;
-    private findCallsUntilLast;
+    private seekChainUntilLeaf;
+    private seekChainUntilRoot;
     private static logDiagnostics;
     static allFiles(dirPaths: string[]): string[];
     /**

package/lib/compiler/typescript/typescript_compiler.js

@@ -86,7 +86,7 @@ class TypeScriptCompiler {
     /**
      * Extract all import nodes
      */
-    extractImports(filepath, $) {
+    extractImports(filepath) {
         log_1.Log.trace('compiler', 'ts', `Extracting imports for file ${(0, string_1.colored)(filepath, 'blue')}`);
         const source = this.getSource(filepath);
         const imports = this.findAll(source, node => {
@@ -94,15 +94,45 @@ class TypeScriptCompiler {
                 return;
             }
             const spec = parser_1.Parser.parseNode(node.moduleSpecifier).value;
-            // Not a relative import, use as it is
-            if (!spec.startsWith('./') && !spec.startsWith('../')) {
-                return node;
+            // Absolute import, use as it is
+            let from;
+            if (spec.startsWith(path.sep)) {
+                from = spec;
             }
-            const from = path.resolve(filepath, '..', spec);
-            if ($?.ignore?.includes(from)) {
-                return;
+            // Relative import
+            else if (spec.startsWith('.' + path.sep) || spec.startsWith('..' + path.sep)) {
+                from = path.resolve(filepath, '..', spec);
+            }
+            // Typing import (future)
+            else if (spec.startsWith('.nesoi' + path.sep)) {
+                from = space_1.Space.path(this.space, spec);
+            }
+            // Non-relative import
+            else {
+                from = space_1.Space.path(this.space, spec);
+                // Check if it exists rooted on the space path (usually libs)
+                // If not, use the original (it comes from a path alias or node_modules)
+                if (!fs.existsSync(from + '.ts'))
+                    from = spec;
+            }
+            const declarations = [];
+            // import Something from '...'
+            if (node.importClause?.name) {
+                declarations.push(ts.factory.createImportDeclaration(node.modifiers, ts.factory.createImportClause(node.importClause.isTypeOnly, node.importClause.name, undefined), ts.factory.createStringLiteral(from, true)));
+            }
+            // import { Something } from '...'
+            if (node.importClause?.namedBindings) {
+                // import * as Something from '...'
+                if ((node.importClause?.namedBindings).name) {
+                    declarations.push(ts.factory.createImportDeclaration(node.modifiers, ts.factory.createImportClause(node.importClause.isTypeOnly, undefined, node.importClause?.namedBindings), ts.factory.createStringLiteral(from, true)));
+                }
+                else {
+                    for (const el of node.importClause.namedBindings.elements) {
+                        declarations.push(ts.factory.createImportDeclaration(node.modifiers, ts.factory.createImportClause(node.importClause.isTypeOnly, undefined, ts.factory.createNamedImports([el])), ts.factory.createStringLiteral(from, true)));
+                    }
+                }
             }
-            return ts.factory.createImportDeclaration(node.modifiers, node.importClause, ts.factory.createStringLiteral(from, true));
+            return declarations;
         });
         const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
         const importStrs = imports.map(node => printer.printNode(ts.EmitHint.Unspecified, node, source));
@@ -162,11 +192,25 @@ class TypeScriptCompiler {
             if (!loopStart && loop.query !== undefined) {
                 loop.query += '.' + p;
             }
+            // Optional
+            let optional = false;
+            if (p.endsWith('?')) {
+                optional = true;
+                p = p.slice(0, -1);
+            }
             // Filter step
-            results = results.map(result => {
+            const new_results = results.map(result => {
                 const ptr = result.node;
-                // TS API object
+                // Function Call
                 if (ts.isCallExpression(ptr)) {
+                    // '#': any argument
+                    if (p === '#') {
+                        return ptr.arguments.map((arg, i) => ({
+                            path: result.path + '▹' + i.toString(),
+                            node: arg
+                        }));
+                    }
+                    // Integer: argument by position
                     const argIdx = parseInt(p);
                     if (!isNaN(argIdx)) {
                         if (argIdx >= ptr.arguments.length) {
@@ -177,29 +221,37 @@ class TypeScriptCompiler {
                             node: ptr.arguments[argIdx]
                         };
                     }
-                    return this.findInCallChain(ptr, node => {
-                        const name = this.getCallName(node);
-                        return p === '*' || name === p;
-                    }).map(node => {
-                        const suffix = (ts.isCallExpression(node) && ts.isStringLiteral(node.arguments[0]))
-                            ? '▹' + node.arguments[0].text
-                            : '';
+                    const ps = p.includes('|') ? p.split('|') : [p];
+                    // '~': Any call in the chain 
+                    // string: chain property by name
+                    return this.findInCallChain(ptr, $ => {
+                        return ps.includes('~') || ps.includes($.path.at(-1) || '~');
+                    }).map($ => {
+                        const firstArg = $.firstArg === '' ? '@' : $.firstArg;
                         return {
-                            path: result.path + '▹' + p + suffix,
-                            node,
+                            path: result.path + '▹' + $.path.at(-1) + (firstArg ? ('▹' + firstArg) : ''),
+                            node: $.isCall ? $.node.parent : $.node,
                         };
                     });
                 }
-                if (ts.isPropertyAccessExpression(ptr)) {
-                    return this.findInCallChain(ptr, parent => {
-                        const name = this.getCallName(parent);
-                        return name === p;
-                    }).map(node => ({
-                        path: result.path + '▹' + p,
-                        node,
-                    }));
+                // Property Access
+                else if (ts.isPropertyAccessExpression(ptr)) {
+                    const ps = p.includes('|') ? p.split('|') : [p];
+                    // '~': Any call in the chain 
+                    // string: chain property by name
+                    return this.findInCallChain(ptr, $ => {
+                        return ps.includes('~') || ps.includes($.path.at(-1) || '~');
+                    }).map($ => {
+                        const firstArg = $.firstArg === '' ? '@' : $.firstArg;
+                        return {
+                            path: result.path + '▹' + $.path.at(-1) + (firstArg ? ('▹' + firstArg) : ''),
+                            node: $.isCall ? $.node.parent : $.node,
+                        };
+                    });
                 }
-                if (ts.isFunctionExpression(ptr) || ts.isArrowFunction(ptr)) {
+                // Function
+                else if (ts.isFunctionExpression(ptr) || ts.isArrowFunction(ptr)) {
+                    // 'return': Return node of function
                     if (p === 'return') {
                         const node = this.getReturnNode(ptr);
                         if (!node) {
@@ -210,9 +262,13 @@ class TypeScriptCompiler {
                             node
                         };
                     }
-                    throw new Error('You can only query functions with .return');
+                    return [];
                 }
-                if (ts.isObjectLiteralExpression(ptr)) {
+                // Object
+                else if (ts.isObjectLiteralExpression(ptr)) {
+                    // '*': Any key
+                    // '**': Any key, recursively
+                    // string: A specific key
                     const parseObj = (node, path, nested = false) => {
                         return node.properties.map(prop => {
                             if (!ts.isPropertyAssignment(prop)) {
@@ -248,6 +304,12 @@ class TypeScriptCompiler {
                 }
                 return [];
             }).flat(1);
+            if (optional) {
+                results = [...results, ...new_results];
+            }
+            else {
+                results = new_results;
+            }
             // Loop behavior
             if (loopEnd) {
                 let loopResults = results;
@@ -376,7 +438,7 @@ class TypeScriptCompiler {
     }
     findAllNesoiBuilders(node) {
         const Nesoi = this.getNesoiSymbol('Space', 'lib/engine/space.d.ts');
-        const allBuilders = this.findAll(node, node => this.isCall(node, Nesoi) ? node : undefined);
+        const allBuilders = this.findAll(node, node => this.isCall(node, Nesoi) ? [node] : undefined);
         const builders = {};
         allBuilders.forEach(b => {
             if (!ts.isCallExpression(b)) {
@@ -419,7 +481,7 @@ class TypeScriptCompiler {
         const visit = (node) => {
             const result = predicate(node);
             if (result) {
-                found.push(result);
+                found.push(...result);
             }
             return node.forEachChild((child) => visit(child));
         };
@@ -437,71 +499,73 @@ class TypeScriptCompiler {
     }
     findInCallChain(node, predicate) {
         const results = [];
-        const from = this.findCallsUntilRoot(node);
-        const to = this.findCallsUntilLast(node);
+        const from = this.seekChainUntilLeaf(node);
+        const to = this.seekChainUntilRoot(node);
         from.reverse();
         const calls = [
             ...from,
-            ...(ts.isCallExpression(node) ? [node] : []),
+            ...(ts.isPropertyAccessExpression(node) ? [node] : []),
             ...to
         ];
-        for (const call of calls) {
-            if (predicate(call)) {
-                results.push(call);
+        const path = [];
+        for (const node of calls) {
+            path.push(node.name.text);
+            const isCall = ts.isCallExpression(node.parent) && node.parent.expression === node;
+            // [Nesoi Syntax]
+            // If the first argument of a call expression is a string,
+            // we assume it's relevant to the path
+            // So we add it after the call expresion name
+            let firstArg = undefined;
+            if (isCall
+                && node.parent.arguments.length
+                && ts.isStringLiteral(node.parent.arguments[0])) {
+                firstArg = node.parent.arguments[0].text;
+            }
+            if (predicate({ node, path, isCall, firstArg })) {
+                results.push({ node, path: [...path], isCall, firstArg });
             }
         }
         return results;
     }
-    findCallsUntilRoot(from) {
-        const calls = [];
-        let node = from;
-        while (node) {
-            if (!ts.isCallExpression(node) && !ts.isPropertyAccessExpression(node)) {
-                return calls;
-            }
-            if (!node.expression || !ts.isPropertyAccessExpression(node.expression)) {
-                return calls;
-            }
-            if (!node.expression.expression) {
-                return calls;
+    seekChainUntilLeaf(from) {
+        const chain = [];
+        let child = from.expression;
+        while (child) {
+            if (!ts.isCallExpression(child) && !ts.isPropertyAccessExpression(child)) {
+                break;
             }
-            if (ts.isCallExpression(node.expression.expression)) {
-                calls.push(node.expression.expression);
-                node = node.expression.expression;
+            if (ts.isCallExpression(child)) {
+                child = child.expression;
             }
-            else if (ts.isPropertyAccessExpression(node.expression.expression)) {
-                calls.push(node.expression);
-                node = node.expression;
+            else if (ts.isPropertyAccessExpression(child)) {
+                chain.push(child);
+                child = child.expression;
             }
             else {
-                return calls;
+                break;
             }
         }
-        return calls;
+        return chain;
     }
-    findCallsUntilLast(from) {
-        const calls = [];
-        let node = from;
-        while (node) {
-            if (!node.parent || !ts.isPropertyAccessExpression(node.parent)) {
-                return calls;
-            }
-            if (!node.parent.parent) {
-                return calls;
+    seekChainUntilRoot(from) {
+        const chain = [];
+        let parent = from.parent;
+        while (parent) {
+            if (!ts.isCallExpression(parent) && !ts.isPropertyAccessExpression(parent)) {
+                break;
             }
-            if (ts.isPropertyAccessExpression(node.parent.parent)) {
-                calls.push(node.parent);
-                node = node.parent;
+            if (ts.isCallExpression(parent)) {
+                parent = parent.parent;
             }
-            else if (ts.isCallExpression(node.parent.parent)) {
-                calls.push(node.parent.parent);
-                node = node.parent.parent;
+            else if (ts.isPropertyAccessExpression(parent)) {
+                chain.push(parent);
+                parent = parent.parent;
             }
             else {
-                return calls;
+                break;
             }
         }
-        return calls;
+        return chain;
     }
     static logDiagnostics(diagnostics) {
         if (!diagnostics.length) {

package/lib/elements/blocks/block.builder.d.ts

@@ -1,6 +1,6 @@
 import { $Module, $Space } from "../../schema";
 import { $BlockOutput, $BlockType } from './block.schema';
-import { MessageTemplateDef, MultiMessageTemplateDef } from "../entities/message/template/message_template.builder";
+import { MessageTemplateDef } from "../entities/message/template/message_template.builder";
 import { $Dependency, BuilderNode } from "../../engine/dependency";
 /**
  * @category Builders
@@ -25,15 +25,6 @@ export declare abstract class BlockBuilder<Space extends $Space, Module extends
      * @returns The Builder, for call-chaining
      */
     protected message<Name extends string, Def extends MessageTemplateDef<Space, Module, Name>>(name: Name, def: Def): unknown;
-    /**
-     * @deprecated
-     * Inline messages. These messages are exposed to the module,
-     * with a name prefixed by the block name.
-     * @param def A method which takes a field factory as input and outputs a template builder
-     * @returns The Builder, for call-chaining
-     */
-    /** @deprecated Use `.message` instead. Will be removed on 3.1 */
-    protected messages<Def extends MultiMessageTemplateDef<Space, Module>>(def: Def): unknown;
     authn(...providers: string[]): unknown;
     protected _input(...names: string[]): unknown;
     protected outputRaw(): unknown;

package/lib/elements/blocks/block.builder.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockBuilder = void 0;
-const message_template_field_builder_1 = require("../entities/message/template/message_template_field.builder");
 const message_builder_1 = require("../entities/message/message.builder");
 const dependency_1 = require("../../engine/dependency");
 const name_helpers_1 = require("../../compiler/helpers/name_helpers");
@@ -33,7 +32,6 @@ class BlockBuilder {
      */
     message(name, def) {
         const msgName = `${this.name}${name.length ? ('.' + name) : ''}`;
-        this._inputMsgs.push(new dependency_1.$Dependency(this.module, 'message', msgName));
         const builder = new message_builder_1.MessageBuilder(this.module, msgName)
             .template(def);
         this._inlineNodes.push(new dependency_1.BuilderNode({
@@ -45,36 +43,6 @@ class BlockBuilder {
             filepath: [], // This is added later by Treeshake.blockInlineNodes()
             dependencies: [] // This is added later by Treeshake.*()
         }));
-        const dep = new dependency_1.$Dependency(this.module, 'message', msgName);
-        this._inputMsgs.push(dep);
-        return this;
-    }
-    /**
-     * @deprecated
-     * Inline messages. These messages are exposed to the module,
-     * with a name prefixed by the block name.
-     * @param def A method which takes a field factory as input and outputs a template builder
-     * @returns The Builder, for call-chaining
-     */
-    /** @deprecated Use `.message` instead. Will be removed on 3.1 */
-    messages(def) {
-        const factory = new message_template_field_builder_1.MessageTemplateFieldFactory(this.module);
-        const schema = def(factory);
-        for (const key in schema) {
-            const name = `${this.name}${key.length ? ('.' + key) : ''}`;
-            this._inputMsgs.push(new dependency_1.$Dependency(this.module, 'message', name));
-            const builder = new message_builder_1.MessageBuilder(this.module, name)
-                .template(() => schema[key]);
-            this._inlineNodes.push(new dependency_1.BuilderNode({
-                module: this.module,
-                type: 'message',
-                name,
-                builder,
-                isInline: true,
-                filepath: [], // This is added later by Treeshake.blockInlineNodes()
-                dependencies: [] // This is added later by Treeshake.*()
-            }));
-        }
         return this;
     }
     // Authentication

package/lib/elements/blocks/job/internal/resource_job.builder.d.ts

@@ -48,29 +48,11 @@ export declare class ResourceJobBuilder<Space extends $Space, Module extends $Mo
      */
     input<Def extends MessageTemplateDef<Space, Module, Name>>(def: Def): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, RequiredInput, $MessageInfer<Name, any, ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
         '': RequiredInput[K];
-    }, any, [never, never], [never, never]>; }, import("../../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+    }, any, [false, false], "">; }, import("../../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
         '': RequiredInput[K];
-    }, any, [never, never], [never, never]>; }, ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+    }, any, [false, false], "">; }>, import("../../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
         '': RequiredInput[K];
-    }, any, [never, never], [never, never]>; } extends infer T ? { [K_1 in keyof T]: (ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': RequiredInput[K];
-    }, any, [never, never], [never, never]>; })[K_1] extends MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
-        path: `${K_1 & string}${keyof I & string}`;
-        data: I[keyof I];
-        opt: Opt[0];
-        nul: Nul[0];
-    } : never; } : never>, import("../../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': RequiredInput[K];
-    }, any, [never, never], [never, never]>; }, ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': RequiredInput[K];
-    }, any, [never, never], [never, never]>; } extends infer T_1 ? { [K_2 in keyof T_1]: (ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
-        '': RequiredInput[K];
-    }, any, [never, never], [never, never]>; })[K_2] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
-        path: `${K_2 & string}${keyof O & string}`;
-        data: O[keyof O];
-        opt: Opt_1[1];
-        nul: Nul_1[1];
-    } : never; } : never>>, MsgExtras, Ctx, CtxAfter>;
+    }, any, [false, false], "">; }>>, MsgExtras, Ctx, CtxAfter>;
     /**
      * A function that will build new fields on the input message to be
      * consumed by the job.

package/lib/elements/blocks/job/job.builder.d.ts

@@ -1,7 +1,7 @@
 import { $Module, $Space, ScopedMessage, ScopedMessageName } from "../../../schema";
 import { $Job, $JobAssert, $JobMethod } from './job.schema';
 import { BlockBuilder } from '../block.builder';
-import { MessageTemplateDef, MultiMessageTemplateDef } from "../../entities/message/template/message_template.builder";
+import { MessageTemplateDef } from "../../entities/message/template/message_template.builder";
 import { Overlay } from "../../../engine/util/type";
 import { $MessageInfer } from "../../entities/message/message.infer";
 import { TrxNode } from "../../../engine/transaction/trx_node";
@@ -18,7 +18,9 @@ export type JobExtrasAndAsserts = ({
  * @category Builders
  * @subcategory Block
  */
-export declare class JobBuilder<Space extends $Space, Module extends $Module, Job extends $Job = $Job, Ctx = {}> extends BlockBuilder<Space, Module, 'job'> {
+export declare class JobBuilder<Space extends $Space, Module extends $Module, Job extends $Job = $Job & {
+    '#input': never;
+}, Ctx = {}> extends BlockBuilder<Space, Module, 'job'> {
     $b: "job";
     $j: "Job";
     private _extrasAndAsserts;
@@ -35,25 +37,9 @@ export declare class JobBuilder<Space extends $Space, Module extends $Module, Jo
     }>;
     message<Name extends string, Def extends MessageTemplateDef<Space, Module, Name>, FullName extends string = `${Job['name']}${Name extends '' ? '' : '.'}${Name & string}`, Msg extends $Message = $MessageInfer<FullName, ($: any) => ReturnType<Def>>>(name: Name, def: Def): JobBuilder<Space, Overlay<Module, {
         messages: Overlay<Module["messages"], { [K in FullName]: Msg; }>;
-    }>, Overlay<Job, {
-        "#input": Msg;
-    }>, Ctx>;
-    /** @deprecated Use `.message` instead. Will be removed on 3.1 */
-    messages<Def extends MultiMessageTemplateDef<Space, Module>>(def: Def): JobBuilder<Space, Overlay<Module, {
-        messages: Overlay<Module["messages"], { [K in keyof ReturnType<Def> as `${Job["name"]}${K extends "" ? "" : "."}${K & string}`]: $MessageInfer<`${Job["name"]}${K extends "" ? "" : "."}${K & string}`, ($: any) => ReturnType<Def>[K], ReturnType<Def>[K], import("../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T ? { [K_1 in keyof T]: ReturnType<Def>[K][K_1] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
-            path: `${K_1 & string}${keyof I & string}`;
-            data: I[keyof I];
-            opt: Opt[0];
-            nul: Nul[0];
-        } : never; } : never>, import("../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T_1 ? { [K_2 in keyof T_1]: ReturnType<Def>[K][K_2] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
-            path: `${K_2 & string}${keyof O & string}`;
-            data: O[keyof O];
-            opt: Opt_1[1];
-            nul: Nul_1[1];
-        } : never; } : never>>; }>;
     }>, Job, Ctx>;
-    input<MsgName extends ScopedMessageName<Module, Job['name']>, Msg extends NoInfer<ScopedMessage<Module, Job['name'], MsgName>>>(...def: MsgName[]): JobBuilder<Space, Module, Overlay<Job, {
-        "#input": Msg;
+    input<MsgName extends ScopedMessageName<Module, Job['name']>, Msg extends NoInfer<ScopedMessage<Module, Job['name'], MsgName>>, PreInput extends $Message = Job['#input']['#raw']['$'] extends string ? Job['#input'] : never>(...def: MsgName[]): JobBuilder<Space, Module, Overlay<Job, {
+        "#input": PreInput | Msg;
     }>, Ctx>;
     get output(): {
         raw: <T>() => JobBuilder<Space, Module, Overlay<Job, {

package/lib/elements/blocks/job/job.builder.js

@@ -34,10 +34,6 @@ class JobBuilder extends block_builder_1.BlockBuilder {
     message(name, def) {
         return super.message(name, def);
     }
-    /** @deprecated Use `.message` instead. Will be removed on 3.1 */
-    messages(def) {
-        return super.messages(def);
-    }
     input(...def) {
         return super._input(...def);
     }

package/lib/elements/blocks/machine/machine.builder.d.ts

@@ -1,12 +1,13 @@
 import { $Module, $Space } from "../../../schema";
 import { $Machine, $MachineLogFn } from './machine.schema';
-import { MultiMessageTemplateDef } from "../../entities/message/template/message_template.builder";
+import { MessageTemplateDef } from "../../entities/message/template/message_template.builder";
 import { $MessageInfer } from "../../entities/message/message.infer";
 import { MachineStateDef } from './machine_state.builder';
 import { BlockBuilder } from '../block.builder';
 import { Overlay } from "../../../engine/util/type";
 import { ModuleTree } from "../../../engine/tree";
 import { ResolvedBuilderNode } from "../../../engine/dependency";
+import { $Message } from "../..";
 /**
  * @category Builders
  * @subcategory Block
@@ -22,18 +23,8 @@ export declare class MachineBuilder<Space extends $Space, Module extends $Module
     authn<U extends keyof Space['authnUsers']>(...providers: U[]): MachineBuilder<Space, Module, Name, Overlay<$, {
         "#authn": { [K in U]: Space["authnUsers"][K]; };
     }>>;
-    messages<Def extends MultiMessageTemplateDef<Space, Module>>(def: Def): MachineBuilder<Space, Overlay<Module, {
-        messages: Overlay<Module["messages"], { [K in keyof ReturnType<Def> as `${Name}${K extends "" ? "" : "."}${K & string}`]: $MessageInfer<`${Name}${K extends "" ? "" : "."}${K & string}`, ($: any) => ReturnType<Def>[K], ReturnType<Def>[K], import("../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T ? { [K_1 in keyof T]: ReturnType<Def>[K][K_1] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
-            path: `${K_1 & string}${keyof I & string}`;
-            data: I[keyof I];
-            opt: Opt[0];
-            nul: Nul[0];
-        } : never; } : never>, import("../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T_1 ? { [K_2 in keyof T_1]: ReturnType<Def>[K][K_2] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
-            path: `${K_2 & string}${keyof O & string}`;
-            data: O[keyof O];
-            opt: Opt_1[1];
-            nul: Nul_1[1];
-        } : never; } : never>>; }>;
+    message<Name extends string, Def extends MessageTemplateDef<Space, Module, Name>, FullName extends string = `${$['name']}${Name extends '' ? '' : '.'}${Name & string}`, Msg extends $Message = $MessageInfer<FullName, ($: any) => ReturnType<Def>>>(name: Name, def: Def): MachineBuilder<Space, Overlay<Module, {
+        messages: Overlay<Module["messages"], { [K in FullName]: Msg; }>;
     }>, Name, $>;
     bucket<M extends keyof Module['buckets']>(names: M | M[]): MachineBuilder<Space, Module, Name, $ & {
         "#data": Module["buckets"][M]["#data"];
@@ -49,7 +40,7 @@ export declare class MachineBuilder<Space extends $Space, Module extends $Module
     static build(node: MachineBuilderNode, tree: ModuleTree, module: $Module): {
         schema: $Machine;
         inlineMessages: {
-            [x: string]: import("../..").$Message;
+            [x: string]: $Message;
         };
         inlineJobs: Record<string, import("../..").$Job>;
     };

package/lib/elements/blocks/machine/machine.builder.js

@@ -23,8 +23,8 @@ class MachineBuilder extends block_builder_1.BlockBuilder {
     authn(...providers) {
         return super.authn(...providers);
     }
-    messages(def) {
-        return super.messages(def);
+    message(name, def) {
+        return super.message(name, def);
     }
     /* [Data] */
     bucket(names) {