@mat3ra/wode 2026.5.23-0 → 2026.6.5-0

package/dist/js/units/BaseUnit.d.ts

@@ -0,0 +1,39 @@
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import { type Defaultable } from "@mat3ra/code/dist/js/entity/mixins/DefaultableMixin";
+import { HashedEntity } from "@mat3ra/code/dist/js/entity/mixins/HashedEntityMixin";
+import { type NamedEntity } from "@mat3ra/code/dist/js/entity/mixins/NamedEntityMixin";
+import { type RuntimeItems } from "@mat3ra/code/dist/js/entity/mixins/RuntimeItemsMixin";
+import { Taggable } from "@mat3ra/code/dist/js/entity/mixins/TaggableMixin";
+import type { NameResultSchema } from "@mat3ra/code/dist/js/utils/object";
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { StatusSchema, WorkflowBaseUnitSchema } from "@mat3ra/esse/dist/js/types";
+import { type BaseUnitSchemaMixin } from "../generated/BaseUnitSchemaMixin";
+import { type StatusSchemaMixin } from "../generated/StatusSchemaMixin";
+import { type RuntimeItemsUILogic } from "./mixins/RuntimeItemsUILogicMixin";
+type Schema = WorkflowBaseUnitSchema;
+type Base = typeof InMemoryEntity & Constructor<NamedEntity> & Constructor<Defaultable> & Constructor<Taggable> & Constructor<HashedEntity> & Constructor<RuntimeItems> & Constructor<RuntimeItemsUILogic> & Constructor<BaseUnitSchemaMixin> & Constructor<StatusSchemaMixin>;
+declare const BaseUnit_base: Base;
+declare class BaseUnit<S extends Schema = Schema> extends BaseUnit_base implements Schema {
+    toJSON: () => Schema & AnyObject;
+    _json: Schema & AnyObject;
+    defaultResults: NameResultSchema[];
+    defaultMonitors: NameResultSchema[];
+    defaultPostProcessors: NameResultSchema[];
+    defaultPreProcessors: NameResultSchema[];
+    repetition: number;
+    /**
+     * @param config — `flowchartId` is optional; when absent, a new UUID is generated.
+     */
+    constructor(config: Partial<S> & Pick<S, "name">);
+    get lastStatusUpdate(): {
+        trackedAt: number;
+        status: string;
+        repetition?: number;
+    };
+    getHashObject(): object;
+    isInStatus(status: StatusSchema["status"]): boolean;
+    clone(extraContext: object): this;
+    setRepetition(repetition: number): void;
+}
+export default BaseUnit;

package/dist/js/units/BaseUnit.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const DefaultableMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/DefaultableMixin");
+const HashedEntityMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/HashedEntityMixin");
+const NamedEntityMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/NamedEntityMixin");
+const RuntimeItemsMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/RuntimeItemsMixin");
+const TaggableMixin_1 = require("@mat3ra/code/dist/js/entity/mixins/TaggableMixin");
+const utils_1 = require("@mat3ra/utils");
+const enums_1 = require("../enums");
+const BaseUnitSchemaMixin_1 = require("../generated/BaseUnitSchemaMixin");
+const StatusSchemaMixin_1 = require("../generated/StatusSchemaMixin");
+const RuntimeItemsUILogicMixin_1 = require("./mixins/RuntimeItemsUILogicMixin");
+class BaseUnit extends entity_1.InMemoryEntity {
+    /**
+     * @param config — `flowchartId` is optional; when absent, a new UUID is generated.
+     */
+    constructor(config) {
+        var _a;
+        super({
+            results: [],
+            monitors: [],
+            preProcessors: [],
+            postProcessors: [],
+            ...config,
+            status: config.status || enums_1.UnitStatus.idle,
+            statusTrack: config.statusTrack || [],
+            flowchartId: (_a = config.flowchartId) !== null && _a !== void 0 ? _a : utils_1.Utils.uuid.getUUID(),
+            tags: config.tags || [],
+        });
+        this.defaultResults = [];
+        this.defaultMonitors = [];
+        this.defaultPostProcessors = [];
+        this.defaultPreProcessors = [];
+        this.repetition = 0;
+        this._initRuntimeItems(config);
+    }
+    get lastStatusUpdate() {
+        const statusTrack = (this.statusTrack || []).filter((s) => {
+            return (s.repetition || 0) === this.repetition;
+        });
+        const sortedStatusTrack = statusTrack.sort((a, b) => a.trackedAt - b.trackedAt); // lodash.sortBy(statusTrack, (x) => x.trackedAt);
+        return sortedStatusTrack[sortedStatusTrack.length - 1];
+    }
+    getHashObject() {
+        return { ...this.hashObjectFromRuntimeItems, type: this.type };
+    }
+    isInStatus(status) {
+        return this.status === status;
+    }
+    clone(extraContext) {
+        const flowchartIDOverrideConfigAsExtraContext = {
+            flowchartId: utils_1.Utils.uuid.getUUID(),
+            ...extraContext,
+        };
+        return super.clone(flowchartIDOverrideConfigAsExtraContext);
+    }
+    setRepetition(repetition) {
+        this.repetition = repetition;
+    }
+}
+(0, TaggableMixin_1.taggableMixin)(BaseUnit.prototype);
+(0, HashedEntityMixin_1.hashedEntityMixin)(BaseUnit.prototype);
+(0, RuntimeItemsMixin_1.runtimeItemsMixin)(BaseUnit.prototype);
+(0, RuntimeItemsUILogicMixin_1.runtimeItemsUILogicMixin)(BaseUnit.prototype);
+(0, BaseUnitSchemaMixin_1.baseUnitSchemaMixin)(BaseUnit.prototype);
+(0, StatusSchemaMixin_1.statusSchemaMixin)(BaseUnit.prototype);
+(0, NamedEntityMixin_1.namedEntityMixin)(BaseUnit.prototype);
+(0, DefaultableMixin_1.defaultableEntityMixin)(BaseUnit);
+exports.default = BaseUnit;

package/dist/js/units/ConditionUnit.d.ts

@@ -0,0 +1,17 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { ConditionUnitSchema } from "@mat3ra/esse/dist/js/types";
+import { type ConditionUnitSchemaMixin } from "../generated/ConditionUnitSchemaMixin";
+import BaseUnit from "./BaseUnit";
+type Schema = ConditionUnitSchema;
+type Base = typeof BaseUnit<Schema> & Constructor<ConditionUnitSchemaMixin>;
+export type ConditionUnitConfig = Partial<Schema>;
+declare const ConditionUnit_base: Base;
+declare class ConditionUnit extends ConditionUnit_base implements Schema {
+    toJSON: () => Schema & AnyObject;
+    _json: Schema & AnyObject;
+    static get jsonSchema(): import("json-schema").JSONSchema7 | undefined;
+    constructor(config: ConditionUnitConfig);
+    getHashObject(): object;
+}
+export default ConditionUnit;

package/dist/js/units/ConditionUnit.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const enums_1 = require("../enums");
+const ConditionUnitSchemaMixin_1 = require("../generated/ConditionUnitSchemaMixin");
+const BaseUnit_1 = __importDefault(require("./BaseUnit"));
+class ConditionUnit extends BaseUnit_1.default {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow/unit/condition");
+    }
+    constructor(config) {
+        var _a;
+        const schema = {
+            input: [],
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            monitors: [],
+            then: "",
+            else: "",
+            statement: "true",
+            maxOccurrences: 100,
+            ...config,
+            name: (_a = config.name) !== null && _a !== void 0 ? _a : enums_1.UnitType.condition,
+            type: enums_1.UnitType.condition,
+        };
+        super(schema);
+    }
+    getHashObject() {
+        return { statement: this.statement, maxOccurrences: this.maxOccurrences };
+    }
+}
+(0, ConditionUnitSchemaMixin_1.conditionUnitSchemaMixin)(ConditionUnit.prototype);
+exports.default = ConditionUnit;

package/dist/js/units/ExecutionUnit.d.ts

@@ -0,0 +1,115 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { ExecutionUnitSchema } from "@mat3ra/esse/dist/js/types";
+import { type AnyContextProvider, type ExternalContext } from "../context/providers";
+import type ConvergenceParameter from "../convergence/ConvergenceParameter";
+import { type ExecutionUnitSchemaMixin } from "../generated/ExecutionUnitSchemaMixin";
+import BaseUnit from "./BaseUnit";
+import ExecutionUnitInput from "./ExecutionUnitInput";
+type Schema = ExecutionUnitSchema;
+type Base = typeof BaseUnit & Constructor<ExecutionUnitSchemaMixin>;
+export type ExecutionUnitConfig = Omit<Partial<Schema>, "application"> & SetApplicationProps;
+type SetApplicationProps = Pick<Schema, "application"> & Pick<Partial<Schema>, "executable" | "flavor"> & SetExecutableProps;
+type SetExecutableProps = {
+    executableName?: string;
+    flavorName?: string;
+};
+declare const ExecutionUnit_base: Base;
+declare class ExecutionUnit extends ExecutionUnit_base implements Schema {
+    inputInstances: ExecutionUnitInput[];
+    renderingContext: Partial<ExternalContext>;
+    contextProvidersInstances: AnyContextProvider[];
+    toJSON: () => Schema & AnyObject;
+    _json: Schema & AnyObject;
+    static get jsonSchema(): import("json-schema").JSONSchema7 | undefined;
+    constructor(config: ExecutionUnitConfig);
+    setApplication({ application, executable, flavor, executableName, flavorName, }: SetApplicationProps): void;
+    setExecutable({ executableName, flavorName }: SetExecutableProps): void;
+    setFlavor(flavorName?: string): void;
+    /**
+     * Persisted `input[].template` must match the current application/executable (and optional
+     * applicationVersion). Otherwise the stored template is stale, and we take the default from
+     * ApplicationRegistry.
+     */
+    private isPersistedInputItemCompatible;
+    /**
+     * Build `inputInstances` from the current flavor’s defaults (`ApplicationRegistry#getInput(application, flavor)`),
+     * merged with persisted `this.input` from saved workflow JSON. For each input slot from the registry we
+     * prefer a compatible persisted row matched by `template.name`, else by index; incompatible or missing
+     * rows use the registry template. `render()` then serializes from these instances into `this.input`, so UI
+     * and saved JSON stay aligned when Subworkflow re-serializes units after render.
+     */
+    setDefaultInput(): void;
+    render(externalContext: ExternalContext, convergence?: ConvergenceParameter): void;
+    private getContextProvidersInstances;
+    savePersistentContext(): void;
+    saveRenderingContext(externalContext: ExternalContext): void;
+    saveContext(externalContext: ExternalContext): void;
+    getHashObject(): {
+        application: {
+            _id?: string;
+            slug?: string;
+            systemName?: string;
+            schemaVersion?: string;
+            name: string;
+            isDefault?: boolean;
+            shortName: string;
+            summary: string;
+            version: string;
+            build: string;
+            isDefaultVersion?: boolean;
+            hasAdvancedComputeOptions?: boolean;
+            isLicensed?: boolean;
+            isUsingMaterial?: boolean;
+            runConfig?: {
+                commandTemplate: string;
+                outFileName: string;
+            };
+        };
+        executable: {
+            _id?: string;
+            slug?: string;
+            systemName?: string;
+            schemaVersion?: string;
+            name: string;
+            isDefault?: boolean;
+            applicationName: string;
+            applicationVersion: string;
+            hasAdvancedComputeOptions?: boolean;
+        };
+        flavor: {
+            _id?: string;
+            slug?: string;
+            systemName?: string;
+            schemaVersion?: string;
+            name: string;
+            isDefault?: boolean;
+            preProcessors: {
+                name: string;
+                [k: string]: unknown;
+            }[];
+            postProcessors: {
+                name: string;
+                [k: string]: unknown;
+            }[];
+            monitors: {
+                name: string;
+                [k: string]: unknown;
+            }[];
+            results: {
+                name: string;
+                [k: string]: unknown;
+            }[];
+            executableName: string;
+            applicationName: string;
+            applicationVersion: string;
+            input: {
+                templateId?: string;
+                templateName?: string;
+                name: string;
+            }[];
+        };
+        input: string;
+    };
+}
+export default ExecutionUnit;

package/dist/js/units/ExecutionUnit.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const standata_1 = require("@mat3ra/standata");
+const utils_1 = require("@mat3ra/utils");
+const providers_1 = require("../context/providers");
+const enums_1 = require("../enums");
+const ExecutionUnitSchemaMixin_1 = require("../generated/ExecutionUnitSchemaMixin");
+const BaseUnit_1 = __importDefault(require("./BaseUnit"));
+const ExecutionUnitInput_1 = __importDefault(require("./ExecutionUnitInput"));
+class ExecutionUnit extends BaseUnit_1.default {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow/unit/execution");
+    }
+    constructor(config) {
+        const schema = {
+            name: enums_1.UnitType.execution,
+            type: enums_1.UnitType.execution,
+            input: [],
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            monitors: [],
+            context: [],
+            ...config,
+        };
+        super(schema);
+        this.inputInstances = [];
+        this.renderingContext = {};
+        this.contextProvidersInstances = [];
+        this.setApplication(config);
+        this.name = this.name || this.flavor.name || "";
+    }
+    setApplication({ application, executable, flavor, executableName, flavorName, }) {
+        var _a, _b;
+        const currentExecutable = this.prop("executable");
+        const currentFlavor = this.prop("flavor");
+        this.setProp("application", application);
+        this.setExecutable({
+            executableName: (_a = executableName !== null && executableName !== void 0 ? executableName : executable === null || executable === void 0 ? void 0 : executable.name) !== null && _a !== void 0 ? _a : currentExecutable === null || currentExecutable === void 0 ? void 0 : currentExecutable.name,
+            flavorName: (_b = flavorName !== null && flavorName !== void 0 ? flavorName : flavor === null || flavor === void 0 ? void 0 : flavor.name) !== null && _b !== void 0 ? _b : currentFlavor === null || currentFlavor === void 0 ? void 0 : currentFlavor.name,
+        });
+    }
+    setExecutable({ executableName, flavorName }) {
+        const executable = new standata_1.ApplicationRegistry()
+            .getExecutablesByApplication(this.application)
+            .find((executable) => {
+            return executableName ? executable.name === executableName : executable.isDefault;
+        });
+        if (!executable) {
+            throw new Error(`Executable ${executableName} not found`);
+        }
+        this.setProp("executable", executable);
+        this.setFlavor(flavorName);
+    }
+    setFlavor(flavorName) {
+        const flavor = new standata_1.ApplicationRegistry()
+            .getFlavorsByApplicationExecutable(this.application, this.executable)
+            .find((flavor) => (flavorName ? flavor.name === flavorName : flavor.isDefault));
+        if (!flavor) {
+            throw new Error(`Flavor ${flavorName} not found`);
+        }
+        this.defaultResults = flavor.results;
+        this.defaultMonitors = flavor.monitors;
+        this.defaultPreProcessors = flavor.preProcessors;
+        this.defaultPostProcessors = flavor.postProcessors;
+        // flavor is missing on the first run, so do not use getter this.flavor with requiredProperty
+        const previousFlavor = this.prop("flavor");
+        if ((previousFlavor === null || previousFlavor === void 0 ? void 0 : previousFlavor.name) !== flavor.name) {
+            this.results = flavor.results;
+            this.monitors = flavor.monitors;
+            this.preProcessors = flavor.preProcessors;
+            this.postProcessors = flavor.postProcessors;
+        }
+        this.setProp("flavor", flavor);
+        this.setDefaultInput();
+    }
+    /**
+     * Persisted `input[].template` must match the current application/executable (and optional
+     * applicationVersion). Otherwise the stored template is stale, and we take the default from
+     * ApplicationRegistry.
+     */
+    isPersistedInputItemCompatible(item) {
+        var _a;
+        const { template } = item;
+        if (template.applicationName !== this.application.name ||
+            template.executableName !== this.executable.name) {
+            return false;
+        }
+        if (!(0, standata_1.applicationVersionSatisfiesSupportedRange)(this.application.version, (_a = template.applicationVersion) !== null && _a !== void 0 ? _a : "")) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Build `inputInstances` from the current flavor’s defaults (`ApplicationRegistry#getInput(application, flavor)`),
+     * merged with persisted `this.input` from saved workflow JSON. For each input slot from the registry we
+     * prefer a compatible persisted row matched by `template.name`, else by index; incompatible or missing
+     * rows use the registry template. `render()` then serializes from these instances into `this.input`, so UI
+     * and saved JSON stay aligned when Subworkflow re-serializes units after render.
+     */
+    setDefaultInput() {
+        const driverTemplates = new standata_1.ApplicationRegistry().getInput(this.application, this.flavor);
+        const persisted = Array.isArray(this.input) ? this.input : [];
+        this.inputInstances = driverTemplates.map((driverTemplate, index) => {
+            var _a;
+            const persistedItem = (_a = persisted.find((item) => { var _a; return ((_a = item === null || item === void 0 ? void 0 : item.template) === null || _a === void 0 ? void 0 : _a.name) === driverTemplate.name; })) !== null && _a !== void 0 ? _a : persisted[index];
+            if (persistedItem && this.isPersistedInputItemCompatible(persistedItem)) {
+                return new ExecutionUnitInput_1.default(persistedItem);
+            }
+            return ExecutionUnitInput_1.default.createFromTemplate(driverTemplate);
+        });
+        this.input = this.inputInstances.map((input) => input.toJSON());
+    }
+    render(externalContext, convergence) {
+        this.contextProvidersInstances = this.getContextProvidersInstances(externalContext, convergence);
+        this.saveContext(externalContext);
+    }
+    getContextProvidersInstances(externalContext, convergence) {
+        const uniqueContextProviderNames = [
+            ...new Set(this.input
+                .map((input) => {
+                return input.template.contextProviders.map((provider) => {
+                    return provider.name;
+                });
+            })
+                .flat()),
+        ];
+        // TODO: kgrid should be abstracted and selected by user
+        const parameterToContextProviderMap = {
+            N_k: "kgrid",
+            N_k_nonuniform: "kgrid",
+        };
+        return uniqueContextProviderNames
+            .map((name) => {
+            return (0, providers_1.createProvider)(name, this.context, externalContext);
+        })
+            .map((provider) => {
+            if (convergence &&
+                provider.name === parameterToContextProviderMap[convergence.name]) {
+                provider.applyConvergenceParameter(convergence);
+            }
+            return provider;
+        });
+    }
+    savePersistentContext() {
+        const persistentItems = this.contextProvidersInstances.map((p) => p.getContextItemData());
+        this.context = persistentItems.filter((c) => c.isEdited);
+    }
+    saveRenderingContext(externalContext) {
+        const renderingItems = this.contextProvidersInstances.map((p) => p.getContextItemDataForRendering());
+        this.renderingContext = {
+            ...Object.fromEntries(renderingItems.map((context) => [context.name, context.data])),
+            ...externalContext,
+        };
+        this.input = this.inputInstances.map((input) => {
+            return input.render(this.renderingContext).toJSON();
+        });
+    }
+    saveContext(externalContext) {
+        this.savePersistentContext();
+        this.saveRenderingContext(externalContext);
+    }
+    getHashObject() {
+        const { input, flavor, application, executable } = this.toJSON();
+        return {
+            ...super.getHashObject(),
+            application,
+            executable,
+            flavor,
+            input: utils_1.Utils.hash.calculateHashFromObject(input.map(({ template }) => {
+                return utils_1.Utils.str.removeEmptyLinesFromString(utils_1.Utils.str.removeCommentsFromSourceCode(template.content));
+            })),
+        };
+    }
+}
+(0, ExecutionUnitSchemaMixin_1.executionUnitSchemaMixin)(ExecutionUnit.prototype);
+exports.default = ExecutionUnit;

package/dist/js/units/ExecutionUnitInput.d.ts

@@ -0,0 +1,22 @@
+import { Template } from "@mat3ra/ade";
+import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { TemplateSchema } from "@mat3ra/esse/dist/js/types";
+import { type ExecutionUnitInputSchemaMixin } from "../generated/ExecutionUnitInputSchemaMixin";
+type Schema = ExecutionUnitInputSchemaMixin;
+type JSON = Schema & AnyObject;
+type ConstructorConfig = Schema | (Omit<Schema, "template"> & {
+    template: Template;
+});
+interface ExecutionUnitInput extends ExecutionUnitInputSchemaMixin {
+}
+declare class ExecutionUnitInput extends InMemoryEntity implements Schema {
+    _json: JSON;
+    toJSON: () => JSON;
+    toJSONQuick: () => JSON;
+    static get jsonSchema(): import("json-schema").JSONSchema7 | undefined;
+    static createFromTemplate(template: Template | TemplateSchema): ExecutionUnitInput;
+    constructor(config: ConstructorConfig);
+    render(renderingContext: Record<string, unknown>): this;
+}
+export default ExecutionUnitInput;

package/dist/js/units/ExecutionUnitInput.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ade_1 = require("@mat3ra/ade");
+const entity_1 = require("@mat3ra/code/dist/js/entity");
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const standata_1 = require("@mat3ra/standata");
+const nunjucks_1 = __importDefault(require("nunjucks"));
+const ExecutionUnitInputSchemaMixin_1 = require("../generated/ExecutionUnitInputSchemaMixin");
+const env = (0, standata_1.setupNunjucksEnvironment)(new nunjucks_1.default.Environment());
+class ExecutionUnitInput extends entity_1.InMemoryEntity {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow/unit/input/-inputItem");
+    }
+    static createFromTemplate(template) {
+        return new ExecutionUnitInput({
+            template,
+            rendered: template.content,
+            isManuallyChanged: false,
+        });
+    }
+    constructor(config) {
+        const { template } = config;
+        const templateInstance = template instanceof ade_1.Template ? template : new ade_1.Template(template);
+        super({ ...config, template: templateInstance.toJSON() });
+    }
+    render(renderingContext) {
+        if (this.isManuallyChanged) {
+            return this;
+        }
+        try {
+            const rendered = nunjucks_1.default.compile(this.template.content, env).render(renderingContext);
+            this.rendered = rendered || this.template.content;
+            return this;
+        }
+        catch (error) {
+            console.error("Error rendering template", this.template.content);
+            console.error("Rendering context: ", JSON.stringify(renderingContext));
+            console.error("Error", error);
+            throw error;
+        }
+    }
+}
+(0, ExecutionUnitInputSchemaMixin_1.executionUnitInputSchemaMixin)(ExecutionUnitInput.prototype);
+exports.default = ExecutionUnitInput;

package/dist/js/units/IOUnit.d.ts

@@ -0,0 +1,16 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { DataIOUnitSchema } from "@mat3ra/esse/dist/js/types";
+import { type IOUnitSchemaMixin } from "../generated/IOUnitSchemaMixin";
+import BaseUnit from "./BaseUnit";
+type Schema = DataIOUnitSchema;
+type Base = typeof BaseUnit<Schema> & Constructor<IOUnitSchemaMixin>;
+export type IOUnitConfig = Partial<Schema>;
+declare const IOUnit_base: Base;
+declare class IOUnit extends IOUnit_base implements Schema {
+    toJSON: () => Schema & AnyObject;
+    _json: Schema & AnyObject;
+    static get jsonSchema(): import("json-schema").JSONSchema7 | undefined;
+    constructor(config: IOUnitConfig);
+}
+export default IOUnit;

package/dist/js/units/IOUnit.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const enums_1 = require("../enums");
+const IOUnitSchemaMixin_1 = require("../generated/IOUnitSchemaMixin");
+const BaseUnit_1 = __importDefault(require("./BaseUnit"));
+class IOUnit extends BaseUnit_1.default {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow/unit/io");
+    }
+    constructor(config) {
+        const schema = {
+            name: enums_1.UnitType.io,
+            subtype: "input",
+            source: "api",
+            input: [],
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            monitors: [],
+            ...config,
+            type: enums_1.UnitType.io,
+        };
+        super(schema);
+    }
+}
+(0, IOUnitSchemaMixin_1.iOUnitSchemaMixin)(IOUnit.prototype);
+exports.default = IOUnit;

package/dist/js/units/MapUnit.d.ts

@@ -0,0 +1,34 @@
+import type { Constructor } from "@mat3ra/code/dist/js/utils/types";
+import type { AnyObject } from "@mat3ra/esse/dist/js/esse/types";
+import type { MapUnitSchema } from "@mat3ra/esse/dist/js/types";
+import { UnitType } from "../enums";
+import { type MapUnitSchemaMixin } from "../generated/MapUnitSchemaMixin";
+import BaseUnit from "./BaseUnit";
+type Schema = MapUnitSchema;
+export declare const defaultMapConfig: {
+    name: UnitType;
+    type: UnitType;
+    workflowId: string;
+    input: {
+        target: string;
+        scope: string;
+        name: string;
+        values: never[];
+        useValues: boolean;
+    };
+    results: never[];
+    monitors: never[];
+    preProcessors: never[];
+    postProcessors: never[];
+};
+type Base = typeof BaseUnit<Schema> & Constructor<MapUnitSchemaMixin>;
+export type MapUnitConfig = Partial<Omit<Schema, "type">>;
+declare const MapUnit_base: Base;
+declare class MapUnit extends MapUnit_base implements Schema {
+    toJSON: () => Schema & AnyObject;
+    _json: Schema & AnyObject;
+    static get jsonSchema(): import("json-schema").JSONSchema7 | undefined;
+    constructor(config: MapUnitConfig);
+    setWorkflowId(id: string): void;
+}
+export default MapUnit;

package/dist/js/units/MapUnit.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMapConfig = void 0;
+const JSONSchemasInterface_1 = __importDefault(require("@mat3ra/esse/dist/js/esse/JSONSchemasInterface"));
+const enums_1 = require("../enums");
+const MapUnitSchemaMixin_1 = require("../generated/MapUnitSchemaMixin");
+const BaseUnit_1 = __importDefault(require("./BaseUnit"));
+exports.defaultMapConfig = {
+    name: enums_1.UnitType.map,
+    type: enums_1.UnitType.map,
+    workflowId: "",
+    input: {
+        target: "MAP_DATA",
+        scope: "global",
+        name: "",
+        values: [],
+        useValues: false,
+    },
+    results: [],
+    monitors: [],
+    preProcessors: [],
+    postProcessors: [],
+};
+class MapUnit extends BaseUnit_1.default {
+    static get jsonSchema() {
+        return JSONSchemasInterface_1.default.getSchemaById("workflow/unit/flowchart");
+    }
+    constructor(config) {
+        var _a;
+        const schema = {
+            ...exports.defaultMapConfig,
+            ...config,
+            flowchartId: (_a = config.flowchartId) !== null && _a !== void 0 ? _a : "",
+            type: enums_1.UnitType.map,
+        };
+        super(schema);
+    }
+    setWorkflowId(id) {
+        this.setProp("workflowId", id);
+    }
+}
+(0, MapUnitSchemaMixin_1.mapUnitSchemaMixin)(MapUnit.prototype);
+exports.default = MapUnit;