@flusys/nestjs-entity-builder 9.0.1 → 9.1.0

package/fesm/{677.js → 996.js}

@@ -8,8 +8,8 @@ import * as __rspack_external_node_path_806ed179 from "node:path";
 import * as __rspack_external_node_url_3991086a from "node:url";
 import * as __rspack_external_node_worker_threads_28ca7740 from "node:worker_threads";
 import * as __rspack_external_node_dns_c6249ebb from "node:dns";
-export const __rspack_esm_id = 677;
-export const __rspack_esm_ids = [677];
+export const __rspack_esm_id = 996;
+export const __rspack_esm_ids = [996];
 export const __webpack_modules__ = {
 6576(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 const ENTITY_BUILDER_MODULE_OPTIONS = 'ENTITY_BUILDER_MODULE_OPTIONS';
@@ -59,60 +59,6 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
-},
-4816(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var node_crypto__rspack_import_0 = __webpack_require__(2561);
-/* import */ var _flow_types_js__rspack_import_1 = __webpack_require__(6256);
-
-
-const API_KEY_PREFIX_LENGTH = 11; // "fk_" + 8 hex
-const hashApiKey = (key)=>(0,node_crypto__rspack_import_0.createHash)('sha256').update(key).digest('hex');
-const apiKeyPrefix = (key)=>key.slice(0, API_KEY_PREFIX_LENGTH);
-/** A key as the designer makes it: `fk_<8 hex>_<32 hex>`. */ function looksLikeApiKey(key) {
-    return typeof key === 'string' && /^fk_[0-9a-f]{8}_[0-9a-f]{32}$/.test(key);
-}
-/** Constant-time comparison of a presented key against a stored hash. */ function apiKeyMatches(presented, storedHash) {
-    const a = Buffer.from(hashApiKey(presented), 'hex');
-    const b = Buffer.from(storedHash, 'hex');
-    return a.length === b.length && (0,node_crypto__rspack_import_0.timingSafeEqual)(a, b);
-}
-/** Whether `presented` is the key a Request step stores. */ const apiKeyOpens = (stored, presented)=>!!stored && looksLikeApiKey(presented) && apiKeyMatches(presented, stored.hash);
-/**
- * What is saved of the Request steps' API keys: a plain key the designer made becomes its prefix and
- * hash, so the key itself is never stored; a step without `api_key` access keeps no key at all.
- */ function sealApiKeys(nodes) {
-    return nodes.map((node)=>{
-        if (node.type !== 'trigger' || node.config?.['apiKey'] === undefined) return node;
-        const { apiKey, ...config } = node.config;
-        if (config['authMode'] !== 'api_key') return {
-            ...node,
-            config
-        };
-        if (looksLikeApiKey(apiKey)) return {
-            ...node,
-            config: {
-                ...config,
-                apiKey: {
-                    prefix: apiKeyPrefix(apiKey),
-                    hash: hashApiKey(apiKey)
-                }
-            }
-        };
-        return (0,_flow_types_js__rspack_import_1/* .isStoredApiKey */.xA)(apiKey) ? node : {
-            ...node,
-            config
-        };
-    });
-}
-
-__webpack_require__.d(__webpack_exports__, {
-  Jb: () => (looksLikeApiKey),
-  ue: () => (sealApiKeys)
-}, {
-  NT: apiKeyOpens
-});
-
-
 },
 8333(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
@@ -610,7 +556,7 @@ async function runValidate(cfg, env, state) {
             passed: true
         }
     };
-    const status = cfg.statusCode ?? (failed.every((check)=>(0,flow_graph_validator/* .usesPermissionFunction */.u9)(check.rule)) ? 403 : 400);
+    const status = cfg.statusCode ?? (failed.every((check)=>(0,flow_graph_validator/* .usesPermissionFunction */.u)(check.rule)) ? 403 : 400);
     const errors = failed.map((check)=>({
             field: check.field || check.id,
             message: check.message
@@ -625,16 +571,19 @@ async function runValidate(cfg, env, state) {
 }
 /** `{ allowed, missing }` - `missing` lists the codes the caller does not hold. */ async function runPermissionCheck(cfg, env, state) {
     const codes = (0,rule_permission/* .parsePermissionCodes */.PS)(cfg.codes);
+    let branch;
+    if (cfg.branch === null) branch = null;
+    else if (cfg.branch !== undefined) branch = (0,rule_permission/* .toBranchArgument */.lH)([
+        await env.ruleEngine.resolveExpression(cfg.branch, evaluationContext(state, env))
+    ], 0);
     const permissions = state.permissions ?? env.ruleEngine.createPermissionResolver(state.user);
-    const granted = state.user ? await permissions.granted(undefined) : [];
+    const granted = state.user ? await permissions.granted(branch) : [];
     const missing = codes.filter((code)=>!(0,utils_.matchesPermission)(granted, code));
     const allowed = codes.length > 0 && (cfg.match === 'all' ? missing.length === 0 : missing.length < codes.length);
-    return deniedResult(cfg, {
+    const output = {
         allowed,
         missing
-    }, allowed);
-}
-/** A denied check: `onDenied: branch` follows the `denied` port, otherwise the run is answered `statusCode` (403). */ function deniedResult(cfg, output, allowed) {
+    };
     if (cfg.onDenied === 'branch') return {
         output,
         port: allowed ? 'allowed' : 'denied'
@@ -650,47 +599,6 @@ async function runValidate(cfg, env, state) {
         output
     };
 }
-/** One id, a list of ids, or nothing (undefined / null / empty text), each id once. */ function idList(value) {
-    const items = Array.isArray(value) ? value : [
-        value
-    ];
-    return [
-        ...new Set(items.filter((item)=>item !== undefined && item !== null && item !== '').map(String))
-    ];
-}
-/**
- * `{ userId, companies, branches }` - what the signed-in user may work in (none without a user or
- * the company feature). With `companyIds` / `branchIds` it also answers `allowed` and `missing`:
- * every id asked for must be within reach, and a target that resolves to nothing is a denial, never a pass.
- */ async function runCompanyBranchCheck(cfg, env, state) {
-    const { companies, branches } = state.user ? await env.companyAccess(state.user.id) : {
-        companies: [],
-        branches: []
-    };
-    const output = {
-        userId: state.user?.id ?? null,
-        companies,
-        branches
-    };
-    if (cfg.companyIds === undefined && cfg.branchIds === undefined) return {
-        output
-    };
-    const ctx = evaluationContext(state, env);
-    const wanted = async (expression)=>expression === undefined ? null : idList(await env.ruleEngine.resolveExpression(expression, ctx));
-    const wantedCompanies = await wanted(cfg.companyIds);
-    const wantedBranches = await wanted(cfg.branchIds);
-    const missing = {
-        companyIds: (wantedCompanies ?? []).filter((id)=>!companies.some((company)=>company.id === id)),
-        branchIds: (wantedBranches ?? []).filter((id)=>!branches.some((branch)=>branch.id === id))
-    };
-    const nothingToCheck = wantedCompanies?.length === 0 || wantedBranches?.length === 0;
-    const allowed = !nothingToCheck && !missing.companyIds.length && !missing.branchIds.length;
-    return deniedResult(cfg, {
-        ...output,
-        allowed,
-        missing
-    }, allowed);
-}
 const USES_PERMISSIONS = /\b(permissions|hasPermission|hasAnyPermission|hasAllPermissions)\b/;
 /** The caller as a code step sees it; permission codes (current branch) are fetched only for code that reads them. */ async function codeUser(code, state) {
     const user = state.user;
@@ -819,16 +727,15 @@ async function updateRecord(entityCode, service, values, state) {
 }
 /** @returns false when the record does not exist and `skip` allows that. */ async function deleteRecord(entityCode, service, id, skipMissing, state) {
     countWrite(state);
-    let action;
     try {
-        action = await service.delete(id, state.user, writeOptions(state));
+        await service.delete(id, state.user, writeOptions(state));
     } catch (error) {
         if (skipMissing && error instanceof common_.NotFoundException) return false;
         throw error;
     }
     if (state.qr) state.pendingEvents.push({
         entityCode,
-        action,
+        action: 'deleted',
         row: {
             id
         }
@@ -990,395 +897,6 @@ async function insertChildren(node, child, parentId, env, state) {
         })
     };
 }
-/** As strict as the email module's own check, and without the characters that would break an address header. */ const EMAIL_PATTERN = /^[^\s@,;<>"]+@[^\s@,;<>"]+\.[^\s@,;<>"]+$/;
-const MAX_EMAIL_LENGTH = 254;
-const shown = (value)=>String(typeof value === 'object' && value !== null ? JSON.stringify(value) : value).slice(0, 100);
-/** A value as message text: nothing for null / undefined, JSON for an object. */ function asText(value) {
-    if (value === null || value === undefined) return '';
-    return typeof value === 'object' ? JSON.stringify(value) : String(value);
-}
-/** Reserves `count` sends of the run's budget before any goes out, so a step never sends only some of its messages because of the limit. */ function countMessages(state, count) {
-    if (state.messages + count > flow_types/* .FLOW_LIMITS.MAX_MESSAGES_PER_RUN */.Or.MAX_MESSAGES_PER_RUN) throw new flow_errors/* .FlowLimitError */.IM(message_keys/* .FLOW_ERROR_MESSAGES.TOO_MANY_MESSAGES */.zr.TOO_MANY_MESSAGES, {
-        max: flow_types/* .FLOW_LIMITS.MAX_MESSAGES_PER_RUN */.Or.MAX_MESSAGES_PER_RUN
-    });
-    state.messages += count;
-}
-function assertRecipientCount(node, count, max) {
-    if (count > max) throw new flow_errors/* .FlowLimitError */.IM(message_keys/* .FLOW_ERROR_MESSAGES.TOO_MANY_RECIPIENTS */.zr.TOO_MANY_RECIPIENTS, {
-        node: (0,flow_types/* .nodeLabel */.dA)(node),
-        count,
-        max
-    });
-}
-/** Whatever the module threw, or its `success: false`, fails the step with the reason (a limit stays a limit). */ function sendFailure(key, node, error) {
-    if (error instanceof flow_errors/* .FlowKeyedError */.Hp || error instanceof flow_errors/* .FlowHttpError */.hk) return error;
-    const detail = error instanceof Error ? error.message : String(error);
-    return new flow_errors/* .FlowKeyedError */.Hp(key, {
-        node: (0,flow_types/* .nodeLabel */.dA)(node),
-        detail
-    }, `"${(0,flow_types/* .nodeLabel */.dA)(node)}" could not send: ${detail}`);
-}
-/** Inside a transaction the message waits for the commit, so a run that rolls back sends nothing. */ async function deliver(node, state, send) {
-    if (state.qr) {
-        state.pendingEvents.push({
-            delivery: (0,flow_types/* .nodeLabel */.dA)(node),
-            send
-        });
-        return 'queued';
-    }
-    await send();
-    return 'sent';
-}
-/** One id or a list of them, each once; null / undefined / empty text is none. Anything but an id rejects with `key`. */ function idsOf(node, value, key, text) {
-    const items = (Array.isArray(value) ? value : [
-        value
-    ]).filter((item)=>item !== undefined && item !== null && item !== '');
-    for (const item of items){
-        if (typeof item !== 'string' || !flow_types/* .FLOW_ID_PATTERN.test */.E2.test(item)) {
-            throw new flow_errors/* .FlowHttpError */.hk(400, text(shown(item)), undefined, {
-                messageKey: key,
-                messageVariables: {
-                    node: (0,flow_types/* .nodeLabel */.dA)(node),
-                    value: shown(item)
-                }
-            });
-        }
-    }
-    return [
-        ...new Set(items)
-    ];
-}
-const notificationRecipients = (node, value)=>idsOf(node, value, message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_RECIPIENT_INVALID */.zr.NOTIFICATION_RECIPIENT_INVALID, (shownValue)=>`"${(0,flow_types/* .nodeLabel */.dA)(node)}" cannot notify "${shownValue}": it is not a user id.`);
-/** Addresses: one, a list, or comma / semicolon separated text; each once (case aside), in the order given. */ function emailAddresses(node, value) {
-    const items = (Array.isArray(value) ? value : [
-        value
-    ]).filter((item)=>item !== undefined && item !== null);
-    const seen = new Map();
-    for (const item of items){
-        const parts = typeof item === 'string' ? item.split(/[,;]/) : [
-            item
-        ];
-        for (const part of parts){
-            const address = typeof part === 'string' ? part.trim() : part;
-            if (address === '') continue;
-            if (typeof address !== 'string' || address.length > MAX_EMAIL_LENGTH || !EMAIL_PATTERN.test(address)) {
-                throw new flow_errors/* .FlowHttpError */.hk(400, `"${shown(address)}" is not a valid email address.`, undefined, {
-                    messageKey: message_keys/* .FLOW_ERROR_MESSAGES.EMAIL_ADDRESS_INVALID */.zr.EMAIL_ADDRESS_INVALID,
-                    messageVariables: {
-                        node: (0,flow_types/* .nodeLabel */.dA)(node),
-                        address: shown(address)
-                    }
-                });
-            }
-            if (!seen.has(address.toLowerCase())) seen.set(address.toLowerCase(), address);
-        }
-    }
-    return [
-        ...seen.values()
-    ];
-}
-/** The company a notification shows under: the one given, else the caller's current one. */ function notificationCompany(node, value, given, state) {
-    if (!given) return state.user?.companyId ?? null;
-    if (value === undefined || value === null || value === '') return null;
-    if (typeof value === 'string' && flow_types/* .FLOW_ID_PATTERN.test */.E2.test(value)) return value;
-    throw new flow_errors/* .FlowHttpError */.hk(400, `"${(0,flow_types/* .nodeLabel */.dA)(node)}": "${shown(value)}" is not a company id.`, undefined, {
-        messageKey: message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_COMPANY_INVALID */.zr.NOTIFICATION_COMPANY_INVALID,
-        messageVariables: {
-            node: (0,flow_types/* .nodeLabel */.dA)(node),
-            value: shown(value)
-        }
-    });
-}
-/** Sends `batches` (each already checked) as one step: the run's budget is taken for all of them first; a test run sends nothing. */ async function sendAll(node, state, batches, skipKey, recipients, send) {
-    countMessages(state, batches.length);
-    if (state.mode === 'dry_run') return {
-        output: {
-            skipped: true,
-            reasonKey: skipKey,
-            count: batches.length,
-            recipients
-        },
-        skipped: true
-    };
-    let status = 'sent';
-    for (const batch of batches)status = await deliver(node, state, ()=>send(batch));
-    return status;
-}
-const nobody = (extra = {})=>({
-        output: {
-            skipped: true,
-            reasonKey: message_keys/* .FLOW_SKIP_MESSAGES.NO_RECIPIENTS */.CB.NO_RECIPIENTS,
-            recipients: 0,
-            ...extra
-        },
-        skipped: true
-    });
-/** Title, message, type, data and push of a notification, read in the current scope (the item's, in many mode). */ async function notificationContent(node, cfg, env, state) {
-    const ctx = evaluationContext(state, env);
-    const title = asText(await env.ruleEngine.resolveExpression(cfg.title, ctx)).trim().slice(0, flow_types/* .FLOW_LIMITS.MAX_NOTIFICATION_TITLE_LENGTH */.Or.MAX_NOTIFICATION_TITLE_LENGTH);
-    if (!title) throw new flow_errors/* .FlowHttpError */.hk(400, `The title of "${(0,flow_types/* .nodeLabel */.dA)(node)}" is empty.`, undefined, {
-        messageKey: message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_TITLE_EMPTY */.zr.NOTIFICATION_TITLE_EMPTY,
-        messageVariables: {
-            node: (0,flow_types/* .nodeLabel */.dA)(node)
-        }
-    });
-    const message = cfg.message === undefined ? '' : asText(await env.ruleEngine.resolveExpression(cfg.message, ctx));
-    const data = cfg.data && Object.keys(cfg.data).length ? await mapValues(cfg.data, env, state) : null;
-    return {
-        title,
-        message: message || null,
-        type: cfg.type ?? 'info',
-        data,
-        realtime: cfg.realtime !== false
-    };
-}
-/** One notification to the users `userIds` names, or null when that is nobody. */ async function userNotification(node, cfg, env, state) {
-    const ctx = evaluationContext(state, env);
-    const userIds = notificationRecipients(node, cfg.userIds === undefined ? undefined : await env.ruleEngine.resolveExpression(cfg.userIds, ctx));
-    if (!userIds.length) return null;
-    assertRecipientCount(node, userIds.length, flow_types/* .FLOW_LIMITS.MAX_NOTIFICATION_RECIPIENTS */.Or.MAX_NOTIFICATION_RECIPIENTS);
-    const content = await notificationContent(node, cfg, env, state);
-    const companyId = notificationCompany(node, cfg.companyId === undefined ? undefined : await env.ruleEngine.resolveExpression(cfg.companyId, ctx), cfg.companyId !== undefined, state);
-    return {
-        ...content,
-        userIds,
-        companyId
-    };
-}
-/**
- * A company-wide notification may reach only companies the run may speak for: any, for a run granted
- * the system; otherwise only those the signed-in caller works in.
- */ async function assertMayNotifyCompanies(node, companyIds, env, state) {
-    if (state.runAs === 'system' && state.systemAuthorized === true) return;
-    const reachable = state.user ? new Set((await env.companyAccess(state.user.id)).companies.map((company)=>company.id)) : new Set();
-    const denied = companyIds.find((id)=>!reachable.has(id));
-    if (denied) {
-        throw new flow_errors/* .FlowHttpError */.hk(403, `"${(0,flow_types/* .nodeLabel */.dA)(node)}" may not notify the company "${denied}".`, undefined, {
-            messageKey: message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_COMPANY_DENIED */.zr.NOTIFICATION_COMPANY_DENIED,
-            messageVariables: {
-                node: (0,flow_types/* .nodeLabel */.dA)(node),
-                company: denied
-            }
-        });
-    }
-}
-/** One notification per company that has members, each shown under its own company. */ async function companyNotifications(node, cfg, env, state) {
-    const companyMembers = env.companyMembers;
-    if (!companyMembers) {
-        throw new flow_errors/* .FlowKeyedError */.Hp(message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_COMPANY_UNAVAILABLE */.zr.NOTIFICATION_COMPANY_UNAVAILABLE, {
-            node: (0,flow_types/* .nodeLabel */.dA)(node)
-        }, `"${(0,flow_types/* .nodeLabel */.dA)(node)}" notifies companies, which needs the company feature.`);
-    }
-    const ctx = evaluationContext(state, env);
-    const resolve = async (expression)=>expression === undefined ? undefined : env.ruleEngine.resolveExpression(expression, ctx);
-    const companyIds = idsOf(node, await resolve(cfg.companyIds), message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_COMPANY_INVALID */.zr.NOTIFICATION_COMPANY_INVALID, (value)=>`"${(0,flow_types/* .nodeLabel */.dA)(node)}": "${value}" is not a company id.`);
-    const branchIds = idsOf(node, await resolve(cfg.branchIds), message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_BRANCH_INVALID */.zr.NOTIFICATION_BRANCH_INVALID, (value)=>`"${(0,flow_types/* .nodeLabel */.dA)(node)}": "${value}" is not a branch id.`);
-    if (!companyIds.length) return [];
-    await assertMayNotifyCompanies(node, companyIds, env, state);
-    const content = await notificationContent(node, cfg, env, state);
-    const batches = [];
-    let total = 0;
-    for (const companyId of companyIds){
-        const userIds = await companyMembers(companyId, branchIds.length ? branchIds : undefined);
-        total += userIds.length;
-        assertRecipientCount(node, total, flow_types/* .FLOW_LIMITS.MAX_COMPANY_NOTIFICATION_RECIPIENTS */.Or.MAX_COMPANY_NOTIFICATION_RECIPIENTS);
-        if (userIds.length) batches.push({
-            ...content,
-            userIds,
-            companyId
-        });
-    }
-    return batches;
-}
-/**
- * one: `{ status, recipients }`. many / company: `{ status, count, recipients }` (+ `skipped` items
- * with nobody to notify, in many mode). `status` is `sent`, or `queued` inside a transaction (sent once
- * it commits). Every message is checked before the first goes out; nobody at all skips the step, and
- * a test run checks everything but sends nothing.
- */ async function runSendNotification(node, cfg, env, state) {
-    const notifications = env.notifications;
-    if (!notifications) throw new flow_errors/* .FlowKeyedError */.Hp(message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_UNAVAILABLE */.zr.NOTIFICATION_UNAVAILABLE, {
-        node: (0,flow_types/* .nodeLabel */.dA)(node)
-    }, `"${(0,flow_types/* .nodeLabel */.dA)(node)}" needs the notification module, which this app does not run.`);
-    const target = cfg.target ?? 'one';
-    let batches;
-    let skippedItems = 0;
-    if (target === 'company') {
-        batches = await companyNotifications(node, cfg, env, state);
-    } else if (target === 'many') {
-        const items = await resolveList(node, cfg.items, flow_types/* .FLOW_LIMITS.MAX_MESSAGES_PER_RUN */.Or.MAX_MESSAGES_PER_RUN, env, state);
-        const prepared = await eachItem(state, items, ()=>userNotification(node, cfg, env, state));
-        batches = prepared.filter((batch)=>batch !== null);
-        skippedItems = prepared.length - batches.length;
-    } else {
-        batches = [
-            await userNotification(node, cfg, env, state)
-        ].filter((batch)=>batch !== null);
-    }
-    const counts = target === 'one' ? {} : {
-        count: batches.length,
-        ...target === 'many' ? {
-            skipped: skippedItems
-        } : {}
-    };
-    if (!batches.length) return nobody(counts);
-    const recipients = batches.reduce((sum, batch)=>sum + batch.userIds.length, 0);
-    const sent = await sendAll(node, state, batches, message_keys/* .FLOW_SKIP_MESSAGES.NOTIFICATION */.CB.NOTIFICATION, recipients, async (batch)=>{
-        try {
-            await notifications.sendToMany(batch);
-        } catch (error) {
-            throw sendFailure(message_keys/* .FLOW_ERROR_MESSAGES.NOTIFICATION_FAILED */.zr.NOTIFICATION_FAILED, node, error);
-        }
-    });
-    if (typeof sent !== 'string') return sent;
-    return {
-        output: {
-            status: sent,
-            recipients,
-            ...counts
-        }
-    };
-}
-/** One email, read in the current scope (the item's, in many mode), or null when `to` has no address. */ async function prepareEmail(node, cfg, email, env, state) {
-    const ctx = evaluationContext(state, env);
-    const addresses = async (expression)=>expression === undefined ? [] : emailAddresses(node, await env.ruleEngine.resolveExpression(expression, ctx));
-    const to = await addresses(cfg.to);
-    if (!to.length) return null;
-    // Someone already on `to` gets the email once.
-    const listed = new Set(to.map((address)=>address.toLowerCase()));
-    const notListed = (list)=>{
-        const kept = list.filter((address)=>!listed.has(address.toLowerCase()));
-        kept.forEach((address)=>listed.add(address.toLowerCase()));
-        return kept;
-    };
-    const cc = notListed(await addresses(cfg.cc));
-    const bcc = notListed(await addresses(cfg.bcc));
-    const recipients = to.length + cc.length + bcc.length;
-    assertRecipientCount(node, recipients, flow_types/* .FLOW_LIMITS.MAX_EMAIL_RECIPIENTS */.Or.MAX_EMAIL_RECIPIENTS);
-    const replyTo = await addresses(cfg.replyTo);
-    if (replyTo.length > 1) {
-        throw new flow_errors/* .FlowHttpError */.hk(400, `"${replyTo.join(', ')}" is not a single email address.`, undefined, {
-            messageKey: message_keys/* .FLOW_ERROR_MESSAGES.EMAIL_ADDRESS_INVALID */.zr.EMAIL_ADDRESS_INVALID,
-            messageVariables: {
-                node: (0,flow_types/* .nodeLabel */.dA)(node),
-                address: shown(replyTo.join(', '))
-            }
-        });
-    }
-    const base = {
-        to,
-        ...cc.length ? {
-            cc
-        } : {},
-        ...bcc.length ? {
-            bcc
-        } : {},
-        ...replyTo.length ? {
-            replyTo: replyTo[0]
-        } : {},
-        ...cfg.emailConfigId ? {
-            emailConfigId: cfg.emailConfigId
-        } : {}
-    };
-    const user = state.user;
-    if (cfg.mode === 'template') {
-        const variables = await mapValues(cfg.variables, env, state);
-        const templateSlug = (cfg.templateSlug ?? '').trim();
-        return {
-            recipients,
-            send: ()=>email.sendTemplate({
-                    ...base,
-                    templateSlug,
-                    variables
-                }, user)
-        };
-    }
-    // A line break in a subject would start a new mail header.
-    const subject = asText(cfg.subject === undefined ? '' : await env.ruleEngine.resolveExpression(cfg.subject, ctx)).replace(/[\r\n]+/g, ' ').trim().slice(0, flow_types/* .FLOW_LIMITS.MAX_EMAIL_SUBJECT_LENGTH */.Or.MAX_EMAIL_SUBJECT_LENGTH);
-    if (!subject) throw new flow_errors/* .FlowHttpError */.hk(400, `The subject of "${(0,flow_types/* .nodeLabel */.dA)(node)}" is empty.`, undefined, {
-        messageKey: message_keys/* .FLOW_ERROR_MESSAGES.EMAIL_SUBJECT_EMPTY */.zr.EMAIL_SUBJECT_EMPTY,
-        messageVariables: {
-            node: (0,flow_types/* .nodeLabel */.dA)(node)
-        }
-    });
-    const html = cfg.format === 'html';
-    const body = cfg.body === undefined ? '' : asText(html ? await env.ruleEngine.resolveHtml(cfg.body, ctx) : await env.ruleEngine.resolveExpression(cfg.body, ctx));
-    if (!body.trim()) throw new flow_errors/* .FlowHttpError */.hk(400, `The message of "${(0,flow_types/* .nodeLabel */.dA)(node)}" is empty.`, undefined, {
-        messageKey: message_keys/* .FLOW_ERROR_MESSAGES.EMAIL_BODY_EMPTY */.zr.EMAIL_BODY_EMPTY,
-        messageVariables: {
-            node: (0,flow_types/* .nodeLabel */.dA)(node)
-        }
-    });
-    return {
-        recipients,
-        send: ()=>email.send({
-                ...base,
-                subject,
-                ...html ? {
-                    html: body
-                } : {
-                    text: body
-                }
-            }, user)
-    };
-}
-/**
- * one: `{ status, recipients, messageId }`. many: `{ status, count, recipients, skipped, messageIds }`
- * (one id per email sent, in order). `status` is `sent`, or `queued` inside a transaction (sent once it
- * commits, no ids yet). Every email is checked before the first goes out; no address at all skips the
- * step, and a test run checks everything but sends nothing.
- */ async function runSendEmail(node, cfg, env, state) {
-    const email = env.email;
-    if (!email) throw new flow_errors/* .FlowKeyedError */.Hp(message_keys/* .FLOW_ERROR_MESSAGES.EMAIL_UNAVAILABLE */.zr.EMAIL_UNAVAILABLE, {
-        node: (0,flow_types/* .nodeLabel */.dA)(node)
-    }, `"${(0,flow_types/* .nodeLabel */.dA)(node)}" needs the email module, which this app does not run.`);
-    const many = cfg.target === 'many';
-    let emails;
-    let skippedItems = 0;
-    if (many) {
-        const items = await resolveList(node, cfg.items, flow_types/* .FLOW_LIMITS.MAX_MESSAGES_PER_RUN */.Or.MAX_MESSAGES_PER_RUN, env, state);
-        const prepared = await eachItem(state, items, ()=>prepareEmail(node, cfg, email, env, state));
-        emails = prepared.filter((item)=>item !== null);
-        skippedItems = prepared.length - emails.length;
-    } else {
-        emails = [
-            await prepareEmail(node, cfg, email, env, state)
-        ].filter((prepared)=>prepared !== null);
-    }
-    if (!emails.length) return nobody(many ? {
-        count: 0,
-        skipped: skippedItems
-    } : {});
-    const recipients = emails.reduce((sum, prepared)=>sum + prepared.recipients, 0);
-    const messageIds = [];
-    const sent = await sendAll(node, state, emails, message_keys/* .FLOW_SKIP_MESSAGES.EMAIL */.CB.EMAIL, recipients, async (prepared)=>{
-        let result;
-        try {
-            result = await prepared.send();
-        } catch (error) {
-            throw sendFailure(message_keys/* .FLOW_ERROR_MESSAGES.EMAIL_FAILED */.zr.EMAIL_FAILED, node, error);
-        }
-        if (!result?.success) throw sendFailure(message_keys/* .FLOW_ERROR_MESSAGES.EMAIL_FAILED */.zr.EMAIL_FAILED, node, result?.error || 'The email was not accepted.');
-        messageIds.push(result.messageId ?? null);
-    });
-    if (typeof sent !== 'string') return sent;
-    if (!many) return {
-        output: {
-            status: sent,
-            recipients,
-            messageId: messageIds[0] ?? null
-        }
-    };
-    return {
-        output: {
-            status: sent,
-            count: emails.length,
-            recipients,
-            skipped: skippedItems,
-            messageIds
-        }
-    };
-}
 /** Runs one node. Ports/branching/looping are the executor's job; this only does the node's own work. */ async function runNode(node, env, state) {
     const ctx = evaluationContext(state, env);
     const c = node.config;
@@ -1393,8 +911,6 @@ const nobody = (extra = {})=>({
             return runCode(node, c, state);
         case 'permission_check':
             return runPermissionCheck(c, env, state);
-        case 'company_branch_check':
-            return runCompanyBranchCheck(c, env, state);
         case 'set':
             {
                 const cfg = c;
@@ -1545,7 +1061,6 @@ const nobody = (extra = {})=>({
                         k,
                         String(v ?? '')
                     ]));
-                if (cfg.forwardAuth === true && state.authorization && !Object.keys(headers).some((name)=>name.toLowerCase() === 'authorization')) headers['authorization'] = state.authorization;
                 const body = cfg.body && Object.keys(cfg.body).length ? await mapValues(cfg.body, env, state) : undefined;
                 const remaining = state.deadline - Date.now();
                 if (remaining <= 0) throw new flow_errors/* .FlowLimitError */.IM(message_keys/* .FLOW_ERROR_MESSAGES.OUT_OF_TIME */.zr.OUT_OF_TIME);
@@ -1584,10 +1099,6 @@ const nobody = (extra = {})=>({
                     }
                 };
             }
-        case 'send_notification':
-            return runSendNotification(node, c, env, state);
-        case 'send_email':
-            return runSendEmail(node, c, env, state);
         case 'respond':
             {
                 const cfg = c;
@@ -1868,16 +1379,14 @@ function successResult(state, startedAt) {
 },
 3186(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _flusys_nestjs_shared_utils__rspack_import_0 = __webpack_require__(9216);
-/* import */ var _config_entity_builder_constants_js__rspack_import_9 = __webpack_require__(6576);
-/* import */ var _config_message_keys_js__rspack_import_8 = __webpack_require__(5732);
+/* import */ var _config_entity_builder_constants_js__rspack_import_8 = __webpack_require__(6576);
+/* import */ var _config_message_keys_js__rspack_import_7 = __webpack_require__(5732);
 /* import */ var _interfaces_generic_record_interface_js__rspack_import_1 = __webpack_require__(3372);
-/* import */ var _rule_engine_index_js__rspack_import_2 = __webpack_require__(8429);
+/* import */ var _rule_engine_index_js__rspack_import_2 = __webpack_require__(5920);
 /* import */ var _rule_engine_rule_ip_js__rspack_import_3 = __webpack_require__(809);
 /* import */ var _rule_engine_rule_permission_js__rspack_import_4 = __webpack_require__(5191);
 /* import */ var _rule_engine_rule_regex_js__rspack_import_5 = __webpack_require__(6308);
 /* import */ var _flow_types_js__rspack_import_6 = __webpack_require__(6256);
-/* import */ var _flow_api_key_js__rspack_import_7 = __webpack_require__(4816);
-
 
 
 
@@ -2058,37 +1567,37 @@ function isExpression(value) {
     return !!value && typeof value === 'object' && typeof value.type === 'string';
 }
 /** Expression shape check with the engine's limits (no evaluation). */ function expressionProblem(value, depth = 0, options = {}) {
-    if (!isExpression(value)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.NOT_AN_EXPRESSION */.IP.NOT_AN_EXPRESSION);
-    if (depth > _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_GROUP_DEPTH */.bw.MAX_GROUP_DEPTH) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.TOO_DEEP */.IP.TOO_DEEP);
+    if (!isExpression(value)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.NOT_AN_EXPRESSION */.IP.NOT_AN_EXPRESSION);
+    if (depth > _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_GROUP_DEPTH */.bw.MAX_GROUP_DEPTH) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.TOO_DEEP */.IP.TOO_DEEP);
     switch(value.type){
         case 'literal':
             return null;
         case 'field_ref':
-            return typeof value.ref === 'string' && value.ref.length > 0 ? null : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.EMPTY_REFERENCE */.IP.EMPTY_REFERENCE);
+            return typeof value.ref === 'string' && value.ref.length > 0 ? null : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.EMPTY_REFERENCE */.IP.EMPTY_REFERENCE);
         case 'template':
-            if (typeof value.template !== 'string') return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.NO_TEMPLATE_TEXT */.IP.NO_TEMPLATE_TEXT);
-            return value.template.length <= _rule_engine_index_js__rspack_import_2/* .RULE_TEMPLATE_MAX_LENGTH */.ym ? null : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.TEMPLATE_TOO_LONG */.IP.TEMPLATE_TOO_LONG);
+            if (typeof value.template !== 'string') return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.NO_TEMPLATE_TEXT */.IP.NO_TEMPLATE_TEXT);
+            return value.template.length <= _rule_engine_index_js__rspack_import_2/* .RULE_TEMPLATE_MAX_LENGTH */.ym ? null : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.TEMPLATE_TOO_LONG */.IP.TEMPLATE_TOO_LONG);
         case 'arithmetic':
-            return Array.isArray(value.operands) ? firstProblem(value.operands, depth, options) : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.NO_OPERANDS */.IP.NO_OPERANDS);
+            return Array.isArray(value.operands) ? firstProblem(value.operands, depth, options) : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.NO_OPERANDS */.IP.NO_OPERANDS);
         case 'concat':
-            return Array.isArray(value.parts) ? firstProblem(value.parts, depth, options) : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.NO_PARTS */.IP.NO_PARTS);
+            return Array.isArray(value.parts) ? firstProblem(value.parts, depth, options) : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.NO_PARTS */.IP.NO_PARTS);
         case 'function':
             return functionProblem(value, depth, options);
         case 'lookup':
             return lookupProblem(value, depth, options);
         default:
-            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.UNKNOWN_EXPRESSION_TYPE */.IP.UNKNOWN_EXPRESSION_TYPE, {
+            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.UNKNOWN_EXPRESSION_TYPE */.IP.UNKNOWN_EXPRESSION_TYPE, {
                 type: value.type
             });
     }
 }
 function functionProblem(value, depth, options) {
-    if (!Array.isArray(value.args)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.NO_ARGUMENTS */.IP.NO_ARGUMENTS);
+    if (!Array.isArray(value.args)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.NO_ARGUMENTS */.IP.NO_ARGUMENTS);
     const arity = FUNCTION_ARITY[value.name];
-    if (!arity) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.UNKNOWN_FUNCTION */.IP.UNKNOWN_FUNCTION, {
+    if (!arity) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.UNKNOWN_FUNCTION */.IP.UNKNOWN_FUNCTION, {
         name: String(value.name)
     });
-    if (value.args.length < arity[0] || value.args.length > arity[1]) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.WRONG_ARGUMENT_COUNT */.IP.WRONG_ARGUMENT_COUNT, {
+    if (value.args.length < arity[0] || value.args.length > arity[1]) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.WRONG_ARGUMENT_COUNT */.IP.WRONG_ARGUMENT_COUNT, {
         name: value.name,
         min: arity[0],
         max: arity[1]
@@ -2096,7 +1605,7 @@ function functionProblem(value, depth, options) {
     const unitAt = DURATION_ARG[value.name];
     const unit = unitAt === undefined ? undefined : value.args[unitAt];
     if (unit?.type === 'literal' && !_rule_engine_index_js__rspack_import_2/* .RULE_DURATION_UNITS.includes */.qO.includes(unit.value)) {
-        return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.DURATION_UNIT_INVALID */.IP.DURATION_UNIT_INVALID, {
+        return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.DURATION_UNIT_INVALID */.IP.DURATION_UNIT_INVALID, {
             units: _rule_engine_index_js__rspack_import_2/* .RULE_DURATION_UNITS.join */.qO.join(', ')
         });
     }
@@ -2119,18 +1628,18 @@ function functionProblem(value, depth, options) {
         try {
             parsed = (0,_rule_engine_rule_permission_js__rspack_import_4/* .parsePermissionCodes */.PS)(codes.value);
         } catch  {
-            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .RULE_ENGINE_MESSAGES.TOO_MANY_PERMISSION_CODES */.x3.TOO_MANY_PERMISSION_CODES, {
+            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .RULE_ENGINE_MESSAGES.TOO_MANY_PERMISSION_CODES */.x3.TOO_MANY_PERMISSION_CODES, {
                 max: _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_PERMISSION_CODES */.bw.MAX_PERMISSION_CODES
             });
         }
-        return parsed.length ? null : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.PERMISSION_CODE_REQUIRED */.IP.PERMISSION_CODE_REQUIRED, {
+        return parsed.length ? null : (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.PERMISSION_CODE_REQUIRED */.IP.PERMISSION_CODE_REQUIRED, {
             name: value.name
         });
     }
     if (value.name === 'IP_IN_RANGE') {
         const ranges = literal(1);
         const invalid = ranges.ok ? (0,_rule_engine_rule_ip_js__rspack_import_3/* .invalidIpRange */.I8)(ranges.value) : null;
-        return invalid ? (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.IP_RANGE_INVALID */.IP.IP_RANGE_INVALID, {
+        return invalid ? (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.IP_RANGE_INVALID */.IP.IP_RANGE_INVALID, {
             range: invalid
         }) : null;
     }
@@ -2144,13 +1653,13 @@ function functionProblem(value, depth, options) {
 function patternProblem(pattern) {
     switch((0,_rule_engine_rule_regex_js__rspack_import_5/* .rulePatternProblem */._V)(pattern)){
         case 'too_long':
-            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.REGEX_TOO_LONG */.IP.REGEX_TOO_LONG, {
+            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.REGEX_TOO_LONG */.IP.REGEX_TOO_LONG, {
                 max: _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_REGEX_PATTERN_LENGTH */.bw.MAX_REGEX_PATTERN_LENGTH
             });
         case 'invalid':
-            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.REGEX_INVALID */.IP.REGEX_INVALID);
+            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.REGEX_INVALID */.IP.REGEX_INVALID);
         case 'too_complex':
-            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.REGEX_TOO_COMPLEX */.IP.REGEX_TOO_COMPLEX, {
+            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.REGEX_TOO_COMPLEX */.IP.REGEX_TOO_COMPLEX, {
                 max: _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_REGEX_REPEAT */.bw.MAX_REGEX_REPEAT
             });
         default:
@@ -2158,20 +1667,20 @@ function patternProblem(pattern) {
     }
 }
 function lookupProblem(value, depth, options) {
-    if (typeof value.entity !== 'string' || !_config_entity_builder_constants_js__rspack_import_9/* .ENTITY_CODE_PATTERN.test */.vs.test(value.entity)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.LOOKUP_ENTITY_INVALID */.IP.LOOKUP_ENTITY_INVALID);
-    if (options.knownEntityCodes && !options.knownEntityCodes.has(value.entity)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.LOOKUP_ENTITY_UNKNOWN */.IP.LOOKUP_ENTITY_UNKNOWN, {
+    if (typeof value.entity !== 'string' || !_config_entity_builder_constants_js__rspack_import_8/* .ENTITY_CODE_PATTERN.test */.vs.test(value.entity)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.LOOKUP_ENTITY_INVALID */.IP.LOOKUP_ENTITY_INVALID);
+    if (options.knownEntityCodes && !options.knownEntityCodes.has(value.entity)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.LOOKUP_ENTITY_UNKNOWN */.IP.LOOKUP_ENTITY_UNKNOWN, {
         entity: value.entity
     });
     if (![
         'exists',
         'count',
         'first'
-    ].includes(value.mode)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.LOOKUP_MODE_INVALID */.IP.LOOKUP_MODE_INVALID);
-    if (value.field !== undefined && (typeof value.field !== 'string' || !COLUMN_CODE.test(value.field))) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.LOOKUP_FIELD_INVALID */.IP.LOOKUP_FIELD_INVALID);
-    if (value.sort !== undefined && (typeof value.sort?.field !== 'string' || !COLUMN_CODE.test(value.sort.field))) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.LOOKUP_FIELD_INVALID */.IP.LOOKUP_FIELD_INVALID);
-    if (!value.filter || typeof value.filter !== 'object' || Array.isArray(value.filter)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.LOOKUP_FILTER_INVALID */.IP.LOOKUP_FILTER_INVALID);
+    ].includes(value.mode)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.LOOKUP_MODE_INVALID */.IP.LOOKUP_MODE_INVALID);
+    if (value.field !== undefined && (typeof value.field !== 'string' || !COLUMN_CODE.test(value.field))) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.LOOKUP_FIELD_INVALID */.IP.LOOKUP_FIELD_INVALID);
+    if (value.sort !== undefined && (typeof value.sort?.field !== 'string' || !COLUMN_CODE.test(value.sort.field))) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.LOOKUP_FIELD_INVALID */.IP.LOOKUP_FIELD_INVALID);
+    if (!value.filter || typeof value.filter !== 'object' || Array.isArray(value.filter)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.LOOKUP_FILTER_INVALID */.IP.LOOKUP_FILTER_INVALID);
     for (const [key, item] of Object.entries(value.filter)){
-        if (!COLUMN_CODE.test(key)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.LOOKUP_FILTER_INVALID */.IP.LOOKUP_FILTER_INVALID);
+        if (!COLUMN_CODE.test(key)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.LOOKUP_FILTER_INVALID */.IP.LOOKUP_FILTER_INVALID);
         const problem = filterValueProblem(item, depth, options);
         if (problem) return problem;
     }
@@ -2180,13 +1689,13 @@ function lookupProblem(value, depth, options) {
 /** A filter entry: an expression (eq) or `{ op, value? }` with an expression value. */ function filterValueProblem(item, depth, options) {
     if (!(0,_interfaces_generic_record_interface_js__rspack_import_1/* .isRecordFilterCondition */.t1)(item)) {
         const op = item && typeof item === 'object' && !Array.isArray(item) && !('type' in item) ? item.op : undefined;
-        if (typeof op === 'string' && !_interfaces_generic_record_interface_js__rspack_import_1/* .RECORD_FILTER_OPS.includes */.ox.includes(op)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.FILTER_OPERATOR_UNKNOWN */.IP.FILTER_OPERATOR_UNKNOWN, {
+        if (typeof op === 'string' && !_interfaces_generic_record_interface_js__rspack_import_1/* .RECORD_FILTER_OPS.includes */.ox.includes(op)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.FILTER_OPERATOR_UNKNOWN */.IP.FILTER_OPERATOR_UNKNOWN, {
             op
         });
         return expressionProblem(item, depth + 1, options);
     }
     if (item.op === 'is_null' || item.op === 'not_null') return null;
-    if (item.value === undefined) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.FILTER_VALUE_REQUIRED */.IP.FILTER_VALUE_REQUIRED, {
+    if (item.value === undefined) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.FILTER_VALUE_REQUIRED */.IP.FILTER_VALUE_REQUIRED, {
         op: item.op
     });
     return expressionProblem(item.value, depth + 1, options);
@@ -2200,8 +1709,8 @@ function firstProblem(items, depth, options) {
 }
 function conditionProblem(node, options) {
     const hasLeft = node?.left !== undefined;
-    if (!node || !hasLeft && (typeof node.field !== 'string' || !node.field) || typeof node.comparison !== 'string') return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.CONDITION_INCOMPLETE */.IP.CONDITION_INCOMPLETE);
-    if (!_rule_engine_index_js__rspack_import_2/* .RULE_COMPARISON_OPERATORS.includes */.dJ.includes(node.comparison)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.UNKNOWN_COMPARISON */.IP.UNKNOWN_COMPARISON, {
+    if (!node || !hasLeft && (typeof node.field !== 'string' || !node.field) || typeof node.comparison !== 'string') return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.CONDITION_INCOMPLETE */.IP.CONDITION_INCOMPLETE);
+    if (!_rule_engine_index_js__rspack_import_2/* .RULE_COMPARISON_OPERATORS.includes */.dJ.includes(node.comparison)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.UNKNOWN_COMPARISON */.IP.UNKNOWN_COMPARISON, {
         comparison: node.comparison
     });
     if (hasLeft) {
@@ -2217,15 +1726,15 @@ function conditionProblem(node, options) {
     return null;
 }
 /** Rule group shape check with the engine's limits (no evaluation). */ function groupProblem(group, depth = 0, options = {}) {
-    if (!group || typeof group !== 'object' || !Array.isArray(group.conditions)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.NOT_A_RULE */.IP.NOT_A_RULE);
+    if (!group || typeof group !== 'object' || !Array.isArray(group.conditions)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.NOT_A_RULE */.IP.NOT_A_RULE);
     const g = group;
-    if (depth > _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_GROUP_DEPTH */.bw.MAX_GROUP_DEPTH) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.TOO_DEEP */.IP.TOO_DEEP);
-    if (g.conditions.length > _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_CONDITIONS_PER_GROUP */.bw.MAX_CONDITIONS_PER_GROUP) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.TOO_MANY_CONDITIONS */.IP.TOO_MANY_CONDITIONS);
+    if (depth > _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_GROUP_DEPTH */.bw.MAX_GROUP_DEPTH) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.TOO_DEEP */.IP.TOO_DEEP);
+    if (g.conditions.length > _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_CONDITIONS_PER_GROUP */.bw.MAX_CONDITIONS_PER_GROUP) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.TOO_MANY_CONDITIONS */.IP.TOO_MANY_CONDITIONS);
     if (![
         'AND',
         'OR',
         'NOT'
-    ].includes(g.operator)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SHAPE_MESSAGES.UNKNOWN_OPERATOR */.IP.UNKNOWN_OPERATOR);
+    ].includes(g.operator)) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SHAPE_MESSAGES.UNKNOWN_OPERATOR */.IP.UNKNOWN_OPERATOR);
     for (const node of g.conditions){
         const problem = node && (0,_rule_engine_index_js__rspack_import_2/* .isRuleGroup */.GD)(node) ? groupProblem(node, depth + 1, options) : conditionProblem(node, options);
         if (problem) return problem;
@@ -2241,14 +1750,24 @@ function conditionProblem(node, options) {
     const errors = [];
     const warnings = [];
     const err = (message)=>errors.push(message);
-    if (!_flow_types_js__rspack_import_6/* .FLOW_SLUG_PATTERN.test */.YD.test(flow.slug ?? '')) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.SLUG_INVALID */.qj.SLUG_INVALID));
+    if (!_flow_types_js__rspack_import_6/* .FLOW_SLUG_PATTERN.test */.YD.test(flow.slug ?? '')) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.SLUG_INVALID */.qj.SLUG_INVALID));
+    if (!_flow_types_js__rspack_import_6/* .FLOW_RUN_AS.includes */.gl.includes(flow.runAs)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.RUN_AS_INVALID */.qj.RUN_AS_INVALID, {
+        runAs: String(flow.runAs)
+    }));
+    if (!_flow_types_js__rspack_import_6/* .FLOW_AUTH_MODES.includes */.fO.includes(flow.authMode)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.AUTH_MODE_INVALID */.qj.AUTH_MODE_INVALID, {
+        authMode: String(flow.authMode)
+    }));
+    if (flow.runAs === 'caller' && flow.authMode !== 'jwt' && flow.authMode !== 'permission' && flow.authMode !== 'internal') {
+        err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.RUN_AS_CALLER_NEEDS_AUTH */.qj.RUN_AS_CALLER_NEEDS_AUTH));
+    }
+    validateInputSchema(flow, err);
     const nodes = Array.isArray(flow.nodes) ? flow.nodes : [];
     const edges = Array.isArray(flow.edges) ? flow.edges : [];
-    if (!nodes.length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NO_NODES */.qj.NO_NODES));
-    if (nodes.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_NODES */.Or.MAX_NODES) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TOO_MANY_NODES */.qj.TOO_MANY_NODES, {
+    if (!nodes.length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NO_NODES */.qj.NO_NODES));
+    if (nodes.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_NODES */.Or.MAX_NODES) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TOO_MANY_NODES */.qj.TOO_MANY_NODES, {
         max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_NODES */.Or.MAX_NODES
     }));
-    if (edges.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_EDGES */.Or.MAX_EDGES) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TOO_MANY_EDGES */.qj.TOO_MANY_EDGES, {
+    if (edges.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_EDGES */.Or.MAX_EDGES) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TOO_MANY_EDGES */.qj.TOO_MANY_EDGES, {
         max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_EDGES */.Or.MAX_EDGES
     }));
     if (errors.length && (!nodes.length || nodes.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_NODES */.Or.MAX_NODES || edges.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_EDGES */.Or.MAX_EDGES)) return {
@@ -2258,16 +1777,16 @@ function conditionProblem(node, options) {
     const byId = new Map();
     for (const node of nodes){
         if (!_flow_types_js__rspack_import_6/* .FLOW_NODE_ID_PATTERN.test */.z6.test(node?.id ?? '')) {
-            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_ID_INVALID */.qj.NODE_ID_INVALID, {
+            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_ID_INVALID */.qj.NODE_ID_INVALID, {
                 id: node?.id
             }));
             continue;
         }
-        if (byId.has(node.id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_ID_DUPLICATE */.qj.NODE_ID_DUPLICATE, {
+        if (byId.has(node.id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_ID_DUPLICATE */.qj.NODE_ID_DUPLICATE, {
             id: node.id
         }));
         byId.set(node.id, node);
-        if (!_flow_types_js__rspack_import_6/* .FLOW_NODE_TYPES.includes */.q2.includes(node.type)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_TYPE_UNKNOWN */.qj.NODE_TYPE_UNKNOWN, {
+        if (!_flow_types_js__rspack_import_6/* .FLOW_NODE_TYPES.includes */.q2.includes(node.type)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_TYPE_UNKNOWN */.qj.NODE_TYPE_UNKNOWN, {
             id: node.id,
             type: node.type
         }));
@@ -2280,24 +1799,24 @@ function conditionProblem(node, options) {
     const outgoing = new Map();
     const edgeIds = new Set();
     for (const edge of edges){
-        if (edgeIds.has(edge.id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.EDGE_ID_DUPLICATE */.qj.EDGE_ID_DUPLICATE, {
+        if (edgeIds.has(edge.id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.EDGE_ID_DUPLICATE */.qj.EDGE_ID_DUPLICATE, {
             id: edge.id
         }));
         edgeIds.add(edge.id);
         const from = byId.get(edge.from);
         const to = byId.get(edge.to);
         if (!from || !to) {
-            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.EDGE_DANGLING */.qj.EDGE_DANGLING, {
+            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.EDGE_DANGLING */.qj.EDGE_DANGLING, {
                 from: edge.from,
                 to: edge.to
             }));
             continue;
         }
-        if (edge.from === edge.to) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.EDGE_SELF */.qj.EDGE_SELF, {
+        if (edge.from === edge.to) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.EDGE_SELF */.qj.EDGE_SELF, {
             id: edge.from
         }));
-        if (to.type === 'trigger') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.EDGE_INTO_TRIGGER */.qj.EDGE_INTO_TRIGGER));
-        if (!(0,_flow_types_js__rspack_import_6/* .portsOf */.a5)(from).includes(edge.port)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.EDGE_NO_PORT */.qj.EDGE_NO_PORT, {
+        if (to.type === 'trigger') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.EDGE_INTO_TRIGGER */.qj.EDGE_INTO_TRIGGER));
+        if (!(0,_flow_types_js__rspack_import_6/* .portsOf */.a5)(from).includes(edge.port)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.EDGE_NO_PORT */.qj.EDGE_NO_PORT, {
             id: from.id,
             port: edge.port
         }));
@@ -2313,195 +1832,111 @@ function conditionProblem(node, options) {
     const seenPairs = new Set();
     for (const edge of edges){
         const key = `${edge.from}|${edge.port}|${edge.to}`;
-        if (seenPairs.has(key)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.EDGE_TWICE */.qj.EDGE_TWICE, {
+        if (seenPairs.has(key)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.EDGE_TWICE */.qj.EDGE_TWICE, {
             from: edge.from,
             to: edge.to
         }));
         seenPairs.add(key);
     }
     const cyclic = hasCycle(nodes, outgoing);
-    if (cyclic) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.CYCLE */.qj.CYCLE));
+    if (cyclic) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.CYCLE */.qj.CYCLE));
     const reachable = triggers.length ? new Set(triggers.flatMap((trigger)=>[
             ...reach(trigger.id, outgoing)
         ])) : null;
     for (const node of nodes){
-        if (reachable && !reachable.has(node.id)) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_UNREACHABLE */.qj.NODE_UNREACHABLE, {
+        if (reachable && !reachable.has(node.id)) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_UNREACHABLE */.qj.NODE_UNREACHABLE, {
             node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(node)
         }));
     }
     checkNodeReferences(nodes, byId, flow, err, warnings);
     if (!cyclic && reachable) checkReferenceTiming(nodes, edges, byId, reachable, warnings);
     if (!cyclic) checkLoopDepth(nodes, outgoing, err);
-    // Run-as, transaction and access are a Request step's own: each is checked against the steps its runs reach.
-    const runs = (0,_flow_types_js__rspack_import_6/* .flowEndpoints */.Xr)(flow).map((endpoint)=>({
-            endpoint,
-            label: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(byId.get(endpoint.nodeId) ?? {
-                id: endpoint.nodeId,
-                name: ''
-            }),
-            steps: [
-                ...reach(endpoint.nodeId, outgoing)
-            ].map((id)=>byId.get(id)).filter((node)=>!!node)
-        }));
-    checkEndpointRuns(runs, warnings);
-    checkTransactionUse(flow, runs, outgoing, context, warnings);
+    if (flow.isTransactional && nodes.some((n)=>n.type === 'http_request')) {
+        warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TRANSACTIONAL_HTTP */.qj.TRANSACTIONAL_HTTP));
+    }
+    checkTransactionUse(flow, nodes, outgoing, reachable, context, warnings);
+    if (flow.runAs === 'system' && flow.authMode === 'public' && nodes.some((n)=>n.type.startsWith('entity_') || collectLookupEntities(n.config).size > 0)) {
+        warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.PUBLIC_SYSTEM_ENTITY */.qj.PUBLIC_SYSTEM_ENTITY));
+    }
+    if ((flow.authMode === 'public' || flow.authMode === 'api_key') && nodes.some((n)=>n.type === 'permission_check' || usesPermissionFunction(n.config))) {
+        warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.PERMISSION_WITHOUT_USER */.qj.PERMISSION_WITHOUT_USER));
+    }
     return {
         errors,
         warnings
     };
 }
-const touchesEntities = (node)=>node.type.startsWith('entity_') || collectLookupEntities(node.config).size > 0;
-/** What depends on a Request step's access, run-as and transaction, for the steps its runs reach. A finding shared by several Request steps is reported once. */ function checkEndpointRuns(runs, warnings) {
-    const reported = new Set();
-    const warnOnce = (message)=>{
-        const key = JSON.stringify(message);
-        if (reported.has(key)) return;
-        reported.add(key);
-        warnings.push(message);
-    };
-    const keylessAsCaller = [];
-    for (const { endpoint, label, steps } of runs){
-        if (endpoint.isTransactional) {
-            if (steps.some((n)=>n.type === 'http_request')) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRANSACTIONAL_HTTP */.qj.TRANSACTIONAL_HTTP, {
-                node: label
-            }));
-            // Inside the run's transaction a message is only sent once it commits: a failed send is logged, it cannot take the error path.
-            for (const n of steps)if ((0,_flow_types_js__rspack_import_6/* .isMessageNode */.SE)(n.type) && n.onError === 'continue') warnOnce((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.MESSAGE_AFTER_COMMIT */.qj.MESSAGE_AFTER_COMMIT, {
-                node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(n)
-            }));
-        }
-        if (endpoint.authMode === 'public' && endpoint.runAs === 'system' && steps.some(touchesEntities)) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.PUBLIC_SYSTEM_ENTITY */.qj.PUBLIC_SYSTEM_ENTITY, {
-            node: label
-        }));
-        if (endpoint.authMode === 'public' && steps.some((n)=>(0,_flow_types_js__rspack_import_6/* .isMessageNode */.SE)(n.type))) warnOnce((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.PUBLIC_MESSAGE */.qj.PUBLIC_MESSAGE));
-        // A URL callers reach without signing in has no user: checks deny them, and a run as the caller can touch no entity and notify no company.
-        if (!_flow_types_js__rspack_import_6/* .KEYLESS_AUTH_MODES.has */.d7.has(endpoint.authMode)) continue;
-        if (steps.some((n)=>n.type === 'permission_check' || n.type === 'company_branch_check' || usesPermissionFunction(n.config))) warnOnce((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.PERMISSION_WITHOUT_USER */.qj.PERMISSION_WITHOUT_USER));
-        if (endpoint.runAs !== 'caller') continue;
-        for (const n of steps)if (n.type === 'send_notification' && n.config?.['target'] === 'company') warnOnce((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.COMPANY_NOTIFICATION_WITHOUT_USER */.qj.COMPANY_NOTIFICATION_WITHOUT_USER, {
-            node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(n)
-        }));
-        if (steps.some(touchesEntities)) keylessAsCaller.push(endpoint.path ? `/${endpoint.path}` : '/');
-    }
-    if (keylessAsCaller.length) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.KEYLESS_ENDPOINT_AS_CALLER */.qj.KEYLESS_ENDPOINT_AS_CALLER, {
-        endpoints: keylessAsCaller.join(', ')
-    }));
-}
-/** The Request steps whose runs reach `nodeId`. */ function endpointsReaching(flow, nodeId) {
-    const outgoing = new Map();
-    for (const edge of Array.isArray(flow.edges) ? flow.edges : [])outgoing.set(edge.from, [
-        ...outgoing.get(edge.from) ?? [],
-        {
-            to: edge.to
-        }
-    ]);
-    return (0,_flow_types_js__rspack_import_6/* .flowEndpoints */.Xr)(flow).filter((endpoint)=>reach(endpoint.nodeId, outgoing).has(nodeId));
-}
 /** At least one Request step; at most one on the flow's own URL, the others on distinct paths. */ function checkTriggers(triggers, err) {
-    if (!triggers.length) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_MISSING */.qj.TRIGGER_MISSING));
+    if (!triggers.length) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TRIGGER_MISSING */.qj.TRIGGER_MISSING));
     const main = triggers.filter((trigger)=>!(0,_flow_types_js__rspack_import_6/* .triggerPath */.um)(trigger));
-    if (main.length > 1) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_MAIN_DUPLICATE */.qj.TRIGGER_MAIN_DUPLICATE, {
+    if (main.length > 1) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TRIGGER_MAIN_DUPLICATE */.qj.TRIGGER_MAIN_DUPLICATE, {
         count: main.length
     }));
     const paths = new Set();
     for (const trigger of triggers){
         const path = (0,_flow_types_js__rspack_import_6/* .triggerPath */.um)(trigger);
         if (!path) continue;
-        if (paths.has(path)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_PATH_DUPLICATE */.qj.TRIGGER_PATH_DUPLICATE, {
+        if (paths.has(path)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TRIGGER_PATH_DUPLICATE */.qj.TRIGGER_PATH_DUPLICATE, {
             path
         }));
         paths.add(path);
     }
 }
 /**
- * What the runtime would always refuse, caught on save: an API-key URL called from a run as the
- * caller, a required input left out, a chain that comes back to this flow or nests deeper
+ * What the runtime would always refuse, caught on save: an API-key flow called by a flow running
+ * as the caller, a required input left out, a chain that comes back to this flow or nests deeper
  * than the limit. An inactive flow and an input the called flow does not declare are warnings.
- */ function checkCalledFlow(node, flow, known, err, warn) {
-    const { flowSlug: slug, endpoint, input, inputList } = node.config;
-    const at = {
-        node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(node)
-    };
+ */ function checkCalledFlow(slug, endpoint, input, inputList, flow, known, at, err, warn) {
     const target = known.get(slug);
     const vars = {
         ...at,
         flow: slug
     };
-    if (!target.isActive) warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INACTIVE */.qj.NODE_FLOW_INACTIVE, vars));
+    if (!target.isActive) warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INACTIVE */.qj.NODE_FLOW_INACTIVE, vars));
+    if (target.authMode === 'api_key') {
+        // A function runs as whoever calls it, so it fails only when a flow running as the caller does.
+        if (flow.authMode === 'internal') warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_API_KEY */.qj.NODE_FLOW_API_KEY, vars));
+        else if (flow.runAs === 'caller') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_API_KEY */.qj.NODE_FLOW_API_KEY, vars));
+    }
     const path = typeof endpoint === 'string' && endpoint ? endpoint : null;
     const entry = target.endpoints.find((e)=>e.path === path);
-    if (entry?.authMode === 'api_key') {
-        // A Request step for other flows runs as whoever calls it, so it fails only when a run as the caller reaches it.
-        const starts = endpointsReaching(flow, node.id);
-        if (starts.some((e)=>e.authMode !== 'internal' && e.runAs === 'caller')) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_API_KEY */.qj.NODE_FLOW_API_KEY, vars));
-        else if (starts.some((e)=>e.authMode === 'internal')) warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_API_KEY */.qj.NODE_FLOW_API_KEY, vars));
-    }
     if (!entry) {
-        err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(path ? _config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_ENDPOINT_UNKNOWN */.qj.NODE_FLOW_ENDPOINT_UNKNOWN : _config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_ENDPOINT_REQUIRED */.qj.NODE_FLOW_ENDPOINT_REQUIRED, {
+        err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(path ? _config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_ENDPOINT_UNKNOWN */.qj.NODE_FLOW_ENDPOINT_UNKNOWN : _config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_ENDPOINT_REQUIRED */.qj.NODE_FLOW_ENDPOINT_REQUIRED, {
             ...vars,
             endpoint: path ?? ''
         }));
     } else if (entry.bodyType === 'list') {
-        if (inputList === undefined) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INPUT_LIST_REQUIRED */.qj.NODE_FLOW_INPUT_LIST_REQUIRED, vars));
+        if (inputList === undefined) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INPUT_LIST_REQUIRED */.qj.NODE_FLOW_INPUT_LIST_REQUIRED, vars));
     } else if (inputList !== undefined) {
-        err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INPUT_LIST_UNEXPECTED */.qj.NODE_FLOW_INPUT_LIST_UNEXPECTED, vars));
+        err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INPUT_LIST_UNEXPECTED */.qj.NODE_FLOW_INPUT_LIST_UNEXPECTED, vars));
     } else {
         checkCalledInputs(input, entry.inputSchema, vars, err, warn);
     }
     const loop = callPathTo(slug, flow.slug, known, new Set());
-    if (loop) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_LOOP */.qj.NODE_FLOW_LOOP, {
+    if (loop) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_LOOP */.qj.NODE_FLOW_LOOP, {
         ...at,
         chain: [
             flow.slug,
             ...loop
         ].join(' > ')
     }));
-    if (1 + callDepth(slug, known, new Set()) > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CALL_DEPTH */.Or.MAX_CALL_DEPTH) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_TOO_DEEP */.qj.NODE_FLOW_TOO_DEEP, {
+    if (1 + callDepth(slug, known, new Set()) > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CALL_DEPTH */.Or.MAX_CALL_DEPTH) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_TOO_DEEP */.qj.NODE_FLOW_TOO_DEEP, {
         ...at,
         max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CALL_DEPTH */.Or.MAX_CALL_DEPTH
     }));
 }
-/**
- * What the Call flow steps of `caller` whose call chain reaches `slug` (that flow itself, or one
- * that calls it, however deep) would hit against the flows in `known`: the save errors of those
- * steps, and the flow they run being off (a warning on save, a failure at run).
- */ function callProblems(caller, slug, known) {
-    const problems = [];
-    for (const node of Array.isArray(caller.nodes) ? caller.nodes : []){
-        const c = node?.config ?? {};
-        if (node?.type !== 'call_flow' || typeof c.flowSlug !== 'string') continue;
-        if (c.flowSlug !== slug && !callPathTo(c.flowSlug, slug, known, new Set())) continue;
-        const at = {
-            node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(node)
-        };
-        const target = known.get(c.flowSlug);
-        if (!target) {
-            problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_UNKNOWN */.qj.NODE_FLOW_UNKNOWN, {
-                ...at,
-                flow: c.flowSlug
-            }));
-            continue;
-        }
-        if (!target.isActive) problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INACTIVE */.qj.NODE_FLOW_INACTIVE, {
-            ...at,
-            flow: c.flowSlug
-        }));
-        checkCalledFlow(node, caller, known, (m)=>problems.push(m), []);
-    }
-    return problems;
-}
 /** The named inputs sent to a flow whose body is an object: every required one given, the rest declared. */ function checkCalledInputs(input, schema, vars, err, warn) {
     const given = input && typeof input === 'object' && !Array.isArray(input) ? Object.keys(input) : [];
     if (schema.length) {
         const declared = new Set(schema.map((field)=>field.name));
-        for (const name of given)if (!declared.has(name)) warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INPUT_UNDECLARED */.qj.NODE_FLOW_INPUT_UNDECLARED, {
+        for (const name of given)if (!declared.has(name)) warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INPUT_UNDECLARED */.qj.NODE_FLOW_INPUT_UNDECLARED, {
             ...vars,
             input: name
         }));
     }
     for (const field of schema){
         if (field.required && (field.default === undefined || field.default === null) && !given.includes(field.name)) {
-            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INPUT_MISSING */.qj.NODE_FLOW_INPUT_MISSING, {
+            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_INPUT_MISSING */.qj.NODE_FLOW_INPUT_MISSING, {
                 ...vars,
                 input: field.name
             }));
@@ -2531,36 +1966,42 @@ const touchesEntities = (node)=>node.type.startsWith('entity_') || collectLookup
     running.delete(slug);
     return deepest;
 }
+function validateInputSchema(flow, err) {
+    if (flow.bodyType !== undefined && !_flow_types_js__rspack_import_6/* .FLOW_BODY_TYPES.includes */.Y3.includes(flow.bodyType)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.BODY_TYPE_UNKNOWN */.qj.BODY_TYPE_UNKNOWN, {
+        type: String(flow.bodyType)
+    }));
+    validateInputFields(flow.inputSchema ?? [], '', 1, err);
+}
 /** One level of the request body: the top-level fields, or the fields of an object / list item at `prefix`. */ function validateInputFields(fields, prefix, depth, err) {
-    if (fields.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_INPUT_FIELDS */.Or.MAX_INPUT_FIELDS) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.INPUT_TOO_MANY */.qj.INPUT_TOO_MANY, {
+    if (fields.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_INPUT_FIELDS */.Or.MAX_INPUT_FIELDS) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.INPUT_TOO_MANY */.qj.INPUT_TOO_MANY, {
         max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_INPUT_FIELDS */.Or.MAX_INPUT_FIELDS
     }));
     const seen = new Set();
     for (const field of fields){
         const name = `${prefix}${field?.name ?? ''}`;
-        if (!_flow_types_js__rspack_import_6/* .FLOW_INPUT_NAME_PATTERN.test */.fZ.test(field?.name ?? '')) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.INPUT_NAME_INVALID */.qj.INPUT_NAME_INVALID, {
+        if (!_flow_types_js__rspack_import_6/* .FLOW_INPUT_NAME_PATTERN.test */.fZ.test(field?.name ?? '')) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.INPUT_NAME_INVALID */.qj.INPUT_NAME_INVALID, {
             name
         }));
-        else if (seen.has(field.name)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.INPUT_NAME_DUPLICATE */.qj.INPUT_NAME_DUPLICATE, {
+        else if (seen.has(field.name)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.INPUT_NAME_DUPLICATE */.qj.INPUT_NAME_DUPLICATE, {
             name
         }));
         seen.add(field?.name);
-        if (!_flow_types_js__rspack_import_6/* .FLOW_INPUT_TYPES.includes */.Q7.includes(field?.type)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.INPUT_TYPE_UNKNOWN */.qj.INPUT_TYPE_UNKNOWN, {
+        if (!_flow_types_js__rspack_import_6/* .FLOW_INPUT_TYPES.includes */.Q7.includes(field?.type)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.INPUT_TYPE_UNKNOWN */.qj.INPUT_TYPE_UNKNOWN, {
             name,
             type: field?.type
         }));
         const itemType = field?.type === 'array' ? field.itemType : undefined;
-        if (itemType !== undefined && (itemType === 'array' || !_flow_types_js__rspack_import_6/* .FLOW_INPUT_TYPES.includes */.Q7.includes(itemType))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.INPUT_ITEM_TYPE_UNKNOWN */.qj.INPUT_ITEM_TYPE_UNKNOWN, {
+        if (itemType !== undefined && (itemType === 'array' || !_flow_types_js__rspack_import_6/* .FLOW_INPUT_TYPES.includes */.Q7.includes(itemType))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.INPUT_ITEM_TYPE_UNKNOWN */.qj.INPUT_ITEM_TYPE_UNKNOWN, {
             name,
             type: itemType
         }));
-        if ((field?.type === 'choice' || itemType === 'choice') && !field.options?.length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.INPUT_CHOICE_NO_OPTIONS */.qj.INPUT_CHOICE_NO_OPTIONS, {
+        if ((field?.type === 'choice' || itemType === 'choice') && !field.options?.length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.INPUT_CHOICE_NO_OPTIONS */.qj.INPUT_CHOICE_NO_OPTIONS, {
             name
         }));
         const holdsFields = field?.type === 'object' || itemType === 'object';
         if (!holdsFields || !Array.isArray(field.fields) || !field.fields.length) continue;
         if (depth >= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_INPUT_DEPTH */.Or.MAX_INPUT_DEPTH) {
-            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.INPUT_TOO_DEEP */.qj.INPUT_TOO_DEEP, {
+            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.INPUT_TOO_DEEP */.qj.INPUT_TOO_DEEP, {
                 name,
                 max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_INPUT_DEPTH */.Or.MAX_INPUT_DEPTH
             }));
@@ -2579,7 +2020,7 @@ function validateNodeConfig(node, flow, context, err, warn) {
     };
     const expr = (value, what)=>{
         const problem = expressionProblem(value, 0, shape);
-        if (problem) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_EXPRESSION_PROBLEM */.qj.NODE_EXPRESSION_PROBLEM, {
+        if (problem) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_EXPRESSION_PROBLEM */.qj.NODE_EXPRESSION_PROBLEM, {
             ...at,
             what,
             problem
@@ -2587,7 +2028,7 @@ function validateNodeConfig(node, flow, context, err, warn) {
     };
     const exprMap = (value, kind)=>{
         if (value === undefined) return;
-        if (!value || typeof value !== 'object' || Array.isArray(value)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PAIRS_INVALID */.qj.NODE_PAIRS_INVALID, {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_PAIRS_INVALID */.qj.NODE_PAIRS_INVALID, {
             ...at,
             what: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(kind.list)
         }));
@@ -2597,13 +2038,13 @@ function validateNodeConfig(node, flow, context, err, warn) {
     };
     const filterMap = (value, kind)=>{
         if (value === undefined) return;
-        if (!value || typeof value !== 'object' || Array.isArray(value)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PAIRS_INVALID */.qj.NODE_PAIRS_INVALID, {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_PAIRS_INVALID */.qj.NODE_PAIRS_INVALID, {
             ...at,
             what: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(kind.list)
         }));
         for (const [key, item] of Object.entries(value)){
             const problem = filterValueProblem(item, -1, shape);
-            if (problem) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_EXPRESSION_PROBLEM */.qj.NODE_EXPRESSION_PROBLEM, {
+            if (problem) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_EXPRESSION_PROBLEM */.qj.NODE_EXPRESSION_PROBLEM, {
                 ...at,
                 what: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(kind.item, {
                     name: key
@@ -2614,164 +2055,115 @@ function validateNodeConfig(node, flow, context, err, warn) {
     };
     const rule = (value, what)=>{
         const problem = groupProblem(value, 0, shape);
-        if (problem) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_RULE_PROBLEM */.qj.NODE_RULE_PROBLEM, {
+        if (problem) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_RULE_PROBLEM */.qj.NODE_RULE_PROBLEM, {
             ...at,
             what,
             problem
         }));
     };
     const entity = (value)=>{
-        if (typeof value !== 'string' || !_config_entity_builder_constants_js__rspack_import_9/* .ENTITY_CODE_PATTERN.test */.vs.test(value)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHOOSE_ENTITY */.qj.NODE_CHOOSE_ENTITY, at));
-        if (context.knownEntityCodes && !context.knownEntityCodes.has(value)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_ENTITY_UNKNOWN */.qj.NODE_ENTITY_UNKNOWN, {
+        if (typeof value !== 'string' || !_config_entity_builder_constants_js__rspack_import_8/* .ENTITY_CODE_PATTERN.test */.vs.test(value)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHOOSE_ENTITY */.qj.NODE_CHOOSE_ENTITY, at));
+        if (context.knownEntityCodes && !context.knownEntityCodes.has(value)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_ENTITY_UNKNOWN */.qj.NODE_ENTITY_UNKNOWN, {
             ...at,
             entity: value
         }));
     };
     const KIND = {
         variable: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.VARIABLES */.bc.VARIABLES,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.VARIABLE */.bc.VARIABLE
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.VARIABLES */.bc.VARIABLES,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.VARIABLE */.bc.VARIABLE
         },
         field: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.FIELDS */.bc.FIELDS,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.FIELD */.bc.FIELD
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.FIELDS */.bc.FIELDS,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.FIELD */.bc.FIELD
         },
         filter: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.FILTERS */.bc.FILTERS,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.FILTER */.bc.FILTER
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.FILTERS */.bc.FILTERS,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.FILTER */.bc.FILTER
         },
         input: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.INPUTS */.bc.INPUTS,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.INPUT */.bc.INPUT
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.INPUTS */.bc.INPUTS,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.INPUT */.bc.INPUT
         },
         header: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.HEADERS */.bc.HEADERS,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.HEADER */.bc.HEADER
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.HEADERS */.bc.HEADERS,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.HEADER */.bc.HEADER
         },
         body: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.BODY_VALUES */.bc.BODY_VALUES,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.BODY_VALUE */.bc.BODY_VALUE
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.BODY_VALUES */.bc.BODY_VALUES,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.BODY_VALUE */.bc.BODY_VALUE
         },
         payload: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.PAYLOAD_VALUES */.bc.PAYLOAD_VALUES,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.PAYLOAD_VALUE */.bc.PAYLOAD_VALUE
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.PAYLOAD_VALUES */.bc.PAYLOAD_VALUES,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.PAYLOAD_VALUE */.bc.PAYLOAD_VALUE
         },
         response: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.RESPONSE_VALUES */.bc.RESPONSE_VALUES,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.RESPONSE_VALUE */.bc.RESPONSE_VALUE
-        },
-        data: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.DATA_VALUES */.bc.DATA_VALUES,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.DATA_VALUE */.bc.DATA_VALUE
-        },
-        template: {
-            list: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.TEMPLATE_VALUES */.bc.TEMPLATE_VALUES,
-            item: _config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.TEMPLATE_VALUE */.bc.TEMPLATE_VALUE
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.RESPONSE_VALUES */.bc.RESPONSE_VALUES,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.RESPONSE_VALUE */.bc.RESPONSE_VALUE
         }
     };
-    const optionalExpr = (value, what)=>{
-        if (value !== undefined) expr(value, what);
-    };
-    const serviceRunning = (service, unavailable)=>{
-        if (context.messageServices && !context.messageServices[service]) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(unavailable, at));
-    };
     switch(node.type){
         case 'trigger':
             {
-                if (c.path !== undefined && c.path !== '' && (typeof c.path !== 'string' || !_flow_types_js__rspack_import_6/* .FLOW_ENDPOINT_PATH_PATTERN.test */.YO.test(c.path))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_PATH_INVALID */.qj.TRIGGER_PATH_INVALID, at));
-                if (c.authMode !== undefined && !_flow_types_js__rspack_import_6/* .FLOW_AUTH_MODES.includes */.fO.includes(c.authMode)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_AUTH_INVALID */.qj.TRIGGER_AUTH_INVALID, at));
-                if (c.permissionCode !== undefined && (typeof c.permissionCode !== 'string' || c.permissionCode.length > 255)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_AUTH_INVALID */.qj.TRIGGER_AUTH_INVALID, at));
-                if (c.runAs !== undefined && !_flow_types_js__rspack_import_6/* .FLOW_RUN_AS.includes */.gl.includes(c.runAs)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.RUN_AS_INVALID */.qj.RUN_AS_INVALID, {
-                    ...at,
-                    runAs: String(c.runAs)
-                }));
-                if (c.isTransactional !== undefined && typeof c.isTransactional !== 'boolean') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_TRANSACTION_INVALID */.qj.TRIGGER_TRANSACTION_INVALID, at));
-                if (c.timeoutMs !== undefined && !(Number.isInteger(c.timeoutMs) && c.timeoutMs >= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MIN_TIMEOUT_MS */.Or.MIN_TIMEOUT_MS && c.timeoutMs <= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_TIMEOUT_MS */.Or.MAX_TIMEOUT_MS)) {
-                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_TIMEOUT_RANGE */.qj.TRIGGER_TIMEOUT_RANGE, {
-                        ...at,
-                        min: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MIN_TIMEOUT_MS */.Or.MIN_TIMEOUT_MS / 1000,
-                        max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_TIMEOUT_MS */.Or.MAX_TIMEOUT_MS / 1000
-                    }));
-                }
-                if (c.rateLimitPerMinute !== undefined && !(Number.isInteger(c.rateLimitPerMinute) && c.rateLimitPerMinute >= 0 && c.rateLimitPerMinute <= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_RATE_LIMIT_PER_MINUTE */.Or.MAX_RATE_LIMIT_PER_MINUTE)) {
-                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_RATE_LIMIT_RANGE */.qj.TRIGGER_RATE_LIMIT_RANGE, {
-                        ...at,
-                        max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_RATE_LIMIT_PER_MINUTE */.Or.MAX_RATE_LIMIT_PER_MINUTE
-                    }));
-                }
-                // Without a key an API-key URL could never be called; any other access keeps none.
-                if (c.authMode === 'api_key' && c.apiKey === undefined) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_API_KEY_REQUIRED */.qj.TRIGGER_API_KEY_REQUIRED, at));
-                else if (c.apiKey !== undefined && !(0,_flow_api_key_js__rspack_import_7/* .looksLikeApiKey */.Jb)(c.apiKey) && !(0,_flow_types_js__rspack_import_6/* .isStoredApiKey */.xA)(c.apiKey)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_API_KEY_INVALID */.qj.TRIGGER_API_KEY_INVALID, at));
-                // Field errors are named after the URL (`<path>: <field>`) once a flow has several.
+                if (c.path !== undefined && c.path !== '' && (typeof c.path !== 'string' || !_flow_types_js__rspack_import_6/* .FLOW_ENDPOINT_PATH_PATTERN.test */.YO.test(c.path))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TRIGGER_PATH_INVALID */.qj.TRIGGER_PATH_INVALID, at));
                 const path = (0,_flow_types_js__rspack_import_6/* .triggerPath */.um)(node);
-                if (c.bodyType !== undefined && !_flow_types_js__rspack_import_6/* .FLOW_BODY_TYPES.includes */.Y3.includes(c.bodyType)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.BODY_TYPE_UNKNOWN */.qj.BODY_TYPE_UNKNOWN, {
+                if (!path) break;
+                if (c.bodyType !== undefined && !_flow_types_js__rspack_import_6/* .FLOW_BODY_TYPES.includes */.Y3.includes(c.bodyType)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.BODY_TYPE_UNKNOWN */.qj.BODY_TYPE_UNKNOWN, {
                     type: String(c.bodyType)
                 }));
-                validateInputFields(Array.isArray(c.inputSchema) ? c.inputSchema : [], path ? `${path}: ` : '', 1, err);
+                validateInputFields(Array.isArray(c.inputSchema) ? c.inputSchema : [], `${path}: `, 1, err);
                 break;
             }
         case 'validate':
             validateChecks(c, at, rule, err);
-            if (c.mode !== undefined && c.mode !== 'all' && c.mode !== 'first') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_MODE_INVALID */.qj.NODE_MODE_INVALID, at));
+            if (c.mode !== undefined && c.mode !== 'all' && c.mode !== 'first') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_MODE_INVALID */.qj.NODE_MODE_INVALID, at));
             if (c.statusCode !== undefined && !(Number.isInteger(c.statusCode) && c.statusCode >= 400 && c.statusCode <= 499)) {
-                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_STATUS_4XX */.qj.NODE_STATUS_4XX, at));
+                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_STATUS_4XX */.qj.NODE_STATUS_4XX, at));
             }
             break;
         case 'permission_check':
             {
                 try {
-                    if (!(0,_rule_engine_rule_permission_js__rspack_import_4/* .parsePermissionCodes */.PS)(c.codes).length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_REQUIRED */.qj.NODE_PERMISSION_REQUIRED, at));
+                    if (!(0,_rule_engine_rule_permission_js__rspack_import_4/* .parsePermissionCodes */.PS)(c.codes).length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_REQUIRED */.qj.NODE_PERMISSION_REQUIRED, at));
                 } catch  {
-                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .RULE_ENGINE_MESSAGES.TOO_MANY_PERMISSION_CODES */.x3.TOO_MANY_PERMISSION_CODES, {
+                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .RULE_ENGINE_MESSAGES.TOO_MANY_PERMISSION_CODES */.x3.TOO_MANY_PERMISSION_CODES, {
                         max: _rule_engine_index_js__rspack_import_2/* .RULE_ENGINE_LIMITS.MAX_PERMISSION_CODES */.bw.MAX_PERMISSION_CODES
                     }));
                 }
-                if (c.match !== undefined && c.match !== 'any' && c.match !== 'all') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_OPTION_INVALID */.qj.NODE_PERMISSION_OPTION_INVALID, at));
-                if (c.onDenied !== undefined && c.onDenied !== 'reject' && c.onDenied !== 'branch') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_OPTION_INVALID */.qj.NODE_PERMISSION_OPTION_INVALID, at));
-                if (c.message !== undefined && typeof c.message !== 'string') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_OPTION_INVALID */.qj.NODE_PERMISSION_OPTION_INVALID, at));
+                if (c.match !== undefined && c.match !== 'any' && c.match !== 'all') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_OPTION_INVALID */.qj.NODE_PERMISSION_OPTION_INVALID, at));
+                if (c.onDenied !== undefined && c.onDenied !== 'reject' && c.onDenied !== 'branch') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_OPTION_INVALID */.qj.NODE_PERMISSION_OPTION_INVALID, at));
+                if (c.branch !== undefined && c.branch !== null) expr(c.branch, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_VALUE */.bc.THE_VALUE));
+                if (c.message !== undefined && typeof c.message !== 'string') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_OPTION_INVALID */.qj.NODE_PERMISSION_OPTION_INVALID, at));
                 if (c.statusCode !== undefined && !(Number.isInteger(c.statusCode) && c.statusCode >= 400 && c.statusCode <= 499)) {
-                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_STATUS_4XX */.qj.NODE_STATUS_4XX, at));
-                }
-                break;
-            }
-        case 'company_branch_check':
-            {
-                if (c.companyIds !== undefined) expr(c.companyIds, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_VALUE */.bc.THE_VALUE));
-                if (c.branchIds !== undefined) expr(c.branchIds, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_VALUE */.bc.THE_VALUE));
-                if (c.onDenied !== undefined && c.onDenied !== 'reject' && c.onDenied !== 'branch') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_OPTION_INVALID */.qj.NODE_PERMISSION_OPTION_INVALID, at));
-                // Without an id to check there is nothing to allow or deny.
-                if (c.onDenied === 'branch' && c.companyIds === undefined && c.branchIds === undefined) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_ACCESS_TARGET_REQUIRED */.qj.NODE_ACCESS_TARGET_REQUIRED, at));
-                if (c.message !== undefined && typeof c.message !== 'string') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PERMISSION_OPTION_INVALID */.qj.NODE_PERMISSION_OPTION_INVALID, at));
-                if (c.statusCode !== undefined && !(Number.isInteger(c.statusCode) && c.statusCode >= 400 && c.statusCode <= 499)) {
-                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_STATUS_4XX */.qj.NODE_STATUS_4XX, at));
+                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_STATUS_4XX */.qj.NODE_STATUS_4XX, at));
                 }
                 break;
             }
         case 'set':
             exprMap(c.values, KIND.variable);
-            if (!c.values || !Object.keys(c.values).length) warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_SETS_NOTHING */.qj.NODE_SETS_NOTHING, at));
+            if (!c.values || !Object.keys(c.values).length) warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_SETS_NOTHING */.qj.NODE_SETS_NOTHING, at));
             for (const key of Object.keys(c.values ?? {})){
-                if (!_flow_types_js__rspack_import_6/* .FLOW_INPUT_NAME_PATTERN.test */.fZ.test(key)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_VARIABLE_INVALID */.qj.NODE_VARIABLE_INVALID, {
+                if (!_flow_types_js__rspack_import_6/* .FLOW_INPUT_NAME_PATTERN.test */.fZ.test(key)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_VARIABLE_INVALID */.qj.NODE_VARIABLE_INVALID, {
                     ...at,
                     name: key
                 }));
             }
             break;
         case 'condition':
-            rule(c.rule, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_RULE */.bc.THE_RULE));
+            rule(c.rule, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_RULE */.bc.THE_RULE));
             break;
         case 'switch':
             {
-                expr(c.value, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_VALUE */.bc.THE_VALUE));
+                expr(c.value, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_VALUE */.bc.THE_VALUE));
                 const cases = Array.isArray(c.cases) ? c.cases : [];
-                if (!cases.length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CASE_REQUIRED */.qj.NODE_CASE_REQUIRED, at));
+                if (!cases.length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CASE_REQUIRED */.qj.NODE_CASE_REQUIRED, at));
                 const ids = new Set();
                 for (const item of cases){
-                    if (typeof item.id !== 'string' || !/^[A-Za-z][A-Za-z0-9_]{0,29}$/.test(item.id) || item.id === 'default') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CASE_INVALID */.qj.NODE_CASE_INVALID, {
+                    if (typeof item.id !== 'string' || !/^[A-Za-z][A-Za-z0-9_]{0,29}$/.test(item.id) || item.id === 'default') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CASE_INVALID */.qj.NODE_CASE_INVALID, {
                         ...at,
                         name: String(item.id)
                     }));
-                    else if (ids.has(item.id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CASE_DUPLICATE */.qj.NODE_CASE_DUPLICATE, {
+                    else if (ids.has(item.id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CASE_DUPLICATE */.qj.NODE_CASE_DUPLICATE, {
                         ...at,
                         name: item.id
                     }));
@@ -2780,10 +2172,10 @@ function validateNodeConfig(node, flow, context, err, warn) {
                 break;
             }
         case 'foreach':
-            expr(c.items, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_LIST */.bc.THE_LIST));
-            if (c.collect !== undefined) expr(c.collect, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_COLLECTED_VALUE */.bc.THE_COLLECTED_VALUE));
+            expr(c.items, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_LIST */.bc.THE_LIST));
+            if (c.collect !== undefined) expr(c.collect, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_COLLECTED_VALUE */.bc.THE_COLLECTED_VALUE));
             if (c.maxItems !== undefined && !(Number.isInteger(c.maxItems) && c.maxItems >= 1 && c.maxItems <= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_FOREACH_ITEMS */.Or.MAX_FOREACH_ITEMS)) {
-                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_MAX_ITEMS_RANGE */.qj.NODE_MAX_ITEMS_RANGE, {
+                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_MAX_ITEMS_RANGE */.qj.NODE_MAX_ITEMS_RANGE, {
                     ...at,
                     max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_FOREACH_ITEMS */.Or.MAX_FOREACH_ITEMS
                 }));
@@ -2836,34 +2228,30 @@ function validateNodeConfig(node, flow, context, err, warn) {
             break;
         case 'entity_get':
             entity(c.entityCode);
-            expr(c.id, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_RECORD_ID */.bc.THE_RECORD_ID));
+            expr(c.id, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_RECORD_ID */.bc.THE_RECORD_ID));
             break;
         case 'entity_query':
             entity(c.entityCode);
             filterMap(c.filter, KIND.filter);
-            if (c.search !== undefined) expr(c.search, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_SEARCH_TEXT */.bc.THE_SEARCH_TEXT));
-            if (c.sort !== undefined) {
-                const sort = c.sort;
-                if (typeof sort?.field !== 'string' || !COLUMN_CODE.test(sort.field) || sort.direction !== undefined && sort.direction !== 'ASC' && sort.direction !== 'DESC') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_SORT_INVALID */.qj.NODE_SORT_INVALID, at));
-            }
+            if (c.search !== undefined) expr(c.search, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_SEARCH_TEXT */.bc.THE_SEARCH_TEXT));
             if (c.limit !== undefined && !(Number.isInteger(c.limit) && c.limit >= 1 && c.limit <= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT)) {
-                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_LIMIT_RANGE */.qj.NODE_LIMIT_RANGE, {
+                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_LIMIT_RANGE */.qj.NODE_LIMIT_RANGE, {
                     ...at,
                     max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT
                 }));
             }
             break;
         case 'call_flow':
-            if (typeof c.flowSlug !== 'string' || !_flow_types_js__rspack_import_6/* .FLOW_SLUG_PATTERN.test */.YD.test(c.flowSlug)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHOOSE_FLOW */.qj.NODE_CHOOSE_FLOW, at));
-            else if (c.flowSlug === flow.slug) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CALLS_ITSELF */.qj.NODE_CALLS_ITSELF, at));
-            else if (context.knownFlows && !context.knownFlows.has(c.flowSlug)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_UNKNOWN */.qj.NODE_FLOW_UNKNOWN, {
+            if (typeof c.flowSlug !== 'string' || !_flow_types_js__rspack_import_6/* .FLOW_SLUG_PATTERN.test */.YD.test(c.flowSlug)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHOOSE_FLOW */.qj.NODE_CHOOSE_FLOW, at));
+            else if (c.flowSlug === flow.slug) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CALLS_ITSELF */.qj.NODE_CALLS_ITSELF, at));
+            else if (context.knownFlows && !context.knownFlows.has(c.flowSlug)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FLOW_UNKNOWN */.qj.NODE_FLOW_UNKNOWN, {
                 ...at,
                 flow: c.flowSlug
             }));
-            else if (context.knownFlows) checkCalledFlow(node, flow, context.knownFlows, err, warn);
-            if (c.endpoint !== undefined && c.endpoint !== '' && (typeof c.endpoint !== 'string' || !_flow_types_js__rspack_import_6/* .FLOW_ENDPOINT_PATH_PATTERN.test */.YO.test(c.endpoint))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.TRIGGER_PATH_INVALID */.qj.TRIGGER_PATH_INVALID, at));
+            else if (context.knownFlows) checkCalledFlow(c.flowSlug, c.endpoint, c.input, c.inputList, flow, context.knownFlows, at, err, warn);
+            if (c.endpoint !== undefined && c.endpoint !== '' && (typeof c.endpoint !== 'string' || !_flow_types_js__rspack_import_6/* .FLOW_ENDPOINT_PATH_PATTERN.test */.YO.test(c.endpoint))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TRIGGER_PATH_INVALID */.qj.TRIGGER_PATH_INVALID, at));
             exprMap(c.input, KIND.input);
-            if (c.inputList !== undefined) expr(c.inputList, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_INPUT_LIST */.bc.THE_INPUT_LIST));
+            if (c.inputList !== undefined) expr(c.inputList, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_INPUT_LIST */.bc.THE_INPUT_LIST));
             break;
         case 'http_request':
             {
@@ -2873,13 +2261,12 @@ function validateNodeConfig(node, flow, context, err, warn) {
                     'PUT',
                     'PATCH',
                     'DELETE'
-                ].includes(String(c.method))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHOOSE_METHOD */.qj.NODE_CHOOSE_METHOD, at));
-                expr(c.url, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_URL */.bc.THE_URL));
+                ].includes(String(c.method))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHOOSE_METHOD */.qj.NODE_CHOOSE_METHOD, at));
+                expr(c.url, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_URL */.bc.THE_URL));
                 exprMap(c.headers, KIND.header);
                 exprMap(c.body, KIND.body);
-                if (c.forwardAuth === true) warn.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FORWARDS_TOKEN */.qj.NODE_FORWARDS_TOKEN, at));
                 if (c.timeoutMs !== undefined && !(Number.isInteger(c.timeoutMs) && c.timeoutMs >= 100 && c.timeoutMs <= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_HTTP_TIMEOUT_MS */.Or.MAX_HTTP_TIMEOUT_MS)) {
-                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_TIMEOUT_RANGE */.qj.NODE_TIMEOUT_RANGE, {
+                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_TIMEOUT_RANGE */.qj.NODE_TIMEOUT_RANGE, {
                         ...at,
                         max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_HTTP_TIMEOUT_MS */.Or.MAX_HTTP_TIMEOUT_MS
                     }));
@@ -2887,71 +2274,28 @@ function validateNodeConfig(node, flow, context, err, warn) {
                 break;
             }
         case 'publish_event':
-            if (typeof c.eventName !== 'string' || !/^[a-z][a-z0-9_.-]{1,59}$/.test(c.eventName)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_EVENT_NAME_INVALID */.qj.NODE_EVENT_NAME_INVALID, at));
+            if (typeof c.eventName !== 'string' || !/^[a-z][a-z0-9_.-]{1,59}$/.test(c.eventName)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_EVENT_NAME_INVALID */.qj.NODE_EVENT_NAME_INVALID, at));
             exprMap(c.payload, KIND.payload);
             break;
-        case 'send_notification':
-            {
-                serviceRunning('notification', _config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_NOTIFICATION_UNAVAILABLE */.qj.NODE_NOTIFICATION_UNAVAILABLE);
-                const target = c.target ?? 'one';
-                if (!_flow_types_js__rspack_import_6/* .FLOW_NOTIFICATION_TARGETS.includes */.as.includes(target)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_MESSAGE_TARGET_INVALID */.qj.NODE_MESSAGE_TARGET_INVALID, at));
-                if (target === 'many') expr(c.items, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_LIST */.bc.THE_LIST));
-                if (target === 'company') {
-                    if (context.companyMembers === false) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_NOTIFICATION_COMPANY_UNAVAILABLE */.qj.NODE_NOTIFICATION_COMPANY_UNAVAILABLE, at));
-                    expr(c.companyIds, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_COMPANIES */.bc.THE_COMPANIES));
-                    optionalExpr(c.branchIds, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_BRANCHES */.bc.THE_BRANCHES));
-                } else {
-                    expr(c.userIds, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_RECIPIENTS */.bc.THE_RECIPIENTS));
-                    optionalExpr(c.companyId, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_COMPANY */.bc.THE_COMPANY));
-                }
-                expr(c.title, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_TITLE */.bc.THE_TITLE));
-                optionalExpr(c.message, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_MESSAGE */.bc.THE_MESSAGE));
-                exprMap(c.data, KIND.data);
-                if (c.type !== undefined && !_flow_types_js__rspack_import_6/* .FLOW_NOTIFICATION_TYPES.includes */.LG.includes(c.type)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_NOTIFICATION_OPTION_INVALID */.qj.NODE_NOTIFICATION_OPTION_INVALID, at));
-                if (c.realtime !== undefined && typeof c.realtime !== 'boolean') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_NOTIFICATION_OPTION_INVALID */.qj.NODE_NOTIFICATION_OPTION_INVALID, at));
-                break;
-            }
-        case 'send_email':
-            {
-                serviceRunning('email', _config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_EMAIL_UNAVAILABLE */.qj.NODE_EMAIL_UNAVAILABLE);
-                if (!_flow_types_js__rspack_import_6/* .FLOW_EMAIL_TARGETS.includes */.B9.includes(c.target ?? 'one')) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_MESSAGE_TARGET_INVALID */.qj.NODE_MESSAGE_TARGET_INVALID, at));
-                if (c.target === 'many') expr(c.items, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_LIST */.bc.THE_LIST));
-                expr(c.to, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_RECIPIENTS */.bc.THE_RECIPIENTS));
-                optionalExpr(c.cc, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_CC */.bc.THE_CC));
-                optionalExpr(c.bcc, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_BCC */.bc.THE_BCC));
-                optionalExpr(c.replyTo, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_REPLY_TO */.bc.THE_REPLY_TO));
-                if (c.mode !== undefined && !_flow_types_js__rspack_import_6/* .FLOW_EMAIL_MODES.includes */.v1.includes(c.mode)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_EMAIL_OPTION_INVALID */.qj.NODE_EMAIL_OPTION_INVALID, at));
-                if (c.format !== undefined && !_flow_types_js__rspack_import_6/* .FLOW_EMAIL_FORMATS.includes */.FU.includes(c.format)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_EMAIL_OPTION_INVALID */.qj.NODE_EMAIL_OPTION_INVALID, at));
-                if (c.emailConfigId !== undefined && c.emailConfigId !== '' && (typeof c.emailConfigId !== 'string' || !_flow_types_js__rspack_import_6/* .FLOW_ID_PATTERN.test */.E2.test(c.emailConfigId))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_EMAIL_OPTION_INVALID */.qj.NODE_EMAIL_OPTION_INVALID, at));
-                if (c.mode === 'template') {
-                    const slug = typeof c.templateSlug === 'string' ? c.templateSlug.trim() : '';
-                    if (!slug || slug.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_EMAIL_TEMPLATE_SLUG_LENGTH */.Or.MAX_EMAIL_TEMPLATE_SLUG_LENGTH) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_EMAIL_TEMPLATE_REQUIRED */.qj.NODE_EMAIL_TEMPLATE_REQUIRED, at));
-                    exprMap(c.variables, KIND.template);
-                } else {
-                    expr(c.subject, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_SUBJECT */.bc.THE_SUBJECT));
-                    expr(c.body, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_BODY */.bc.THE_BODY));
-                }
-                break;
-            }
         case 'respond':
             {
                 const status = c.statusCode;
-                if (!(Number.isInteger(status) && status >= 200 && status <= 599)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_STATUS_2XX_5XX */.qj.NODE_STATUS_2XX_5XX, at));
+                if (!(Number.isInteger(status) && status >= 200 && status <= 599)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_STATUS_2XX_5XX */.qj.NODE_STATUS_2XX_5XX, at));
                 exprMap(c.body, KIND.response);
-                if (c.bodyExpression !== undefined) expr(c.bodyExpression, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_RESPONSE */.bc.THE_RESPONSE));
+                if (c.bodyExpression !== undefined) expr(c.bodyExpression, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_RESPONSE */.bc.THE_RESPONSE));
                 break;
             }
         case 'commit':
-            if (node.onError === 'continue') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_COMMIT_CONTINUE */.qj.NODE_COMMIT_CONTINUE, at));
+            if (node.onError === 'continue') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_COMMIT_CONTINUE */.qj.NODE_COMMIT_CONTINUE, at));
             break;
         case 'code':
-            if (typeof c.code !== 'string' || !c.code.trim()) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CODE_REQUIRED */.qj.NODE_CODE_REQUIRED, at));
-            else if (c.code.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CODE_LENGTH */.Or.MAX_CODE_LENGTH) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CODE_TOO_LONG */.qj.NODE_CODE_TOO_LONG, {
+            if (typeof c.code !== 'string' || !c.code.trim()) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CODE_REQUIRED */.qj.NODE_CODE_REQUIRED, at));
+            else if (c.code.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CODE_LENGTH */.Or.MAX_CODE_LENGTH) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CODE_TOO_LONG */.qj.NODE_CODE_TOO_LONG, {
                 ...at,
                 max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CODE_LENGTH */.Or.MAX_CODE_LENGTH
             }));
             if (c.timeoutMs !== undefined && !(Number.isInteger(c.timeoutMs) && c.timeoutMs >= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MIN_CODE_TIMEOUT_MS */.Or.MIN_CODE_TIMEOUT_MS && c.timeoutMs <= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CODE_TIMEOUT_MS */.Or.MAX_CODE_TIMEOUT_MS)) {
-                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CODE_TIMEOUT_RANGE */.qj.NODE_CODE_TIMEOUT_RANGE, {
+                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CODE_TIMEOUT_RANGE */.qj.NODE_CODE_TIMEOUT_RANGE, {
                     ...at,
                     min: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MIN_CODE_TIMEOUT_MS */.Or.MIN_CODE_TIMEOUT_MS,
                     max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CODE_TIMEOUT_MS */.Or.MAX_CODE_TIMEOUT_MS
@@ -2962,19 +2306,19 @@ function validateNodeConfig(node, flow, context, err, warn) {
 }
 /** `target` and what it needs: one - an id; many - a list (the id is optional, the item's own id by default); filter - a filter and a limit. */ function writeTargetConfig(c, targets, notFound, { at, expr, filterMap, err }) {
     const target = c.target ?? 'one';
-    if (typeof target !== 'string' || !targets.includes(target)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_WRITE_TARGET_INVALID */.qj.NODE_WRITE_TARGET_INVALID, at));
-    if (c.onNotFound !== undefined && !notFound.includes(c.onNotFound)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_NOT_FOUND_INVALID */.qj.NODE_NOT_FOUND_INVALID, at));
+    if (typeof target !== 'string' || !targets.includes(target)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_WRITE_TARGET_INVALID */.qj.NODE_WRITE_TARGET_INVALID, at));
+    if (c.onNotFound !== undefined && !notFound.includes(c.onNotFound)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_NOT_FOUND_INVALID */.qj.NODE_NOT_FOUND_INVALID, at));
     const needsId = notFound.length > 0;
-    if (target === 'one' && needsId) expr(c.id, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_RECORD_ID */.bc.THE_RECORD_ID));
+    if (target === 'one' && needsId) expr(c.id, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_RECORD_ID */.bc.THE_RECORD_ID));
     if (target === 'many') {
-        expr(c.items, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_LIST */.bc.THE_LIST));
-        if (needsId && c.id !== undefined) expr(c.id, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_RECORD_ID */.bc.THE_RECORD_ID));
+        expr(c.items, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_LIST */.bc.THE_LIST));
+        if (needsId && c.id !== undefined) expr(c.id, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_RECORD_ID */.bc.THE_RECORD_ID));
     }
     if (target === 'filter') {
         filterMap(c.filter);
-        if (!c.filter || typeof c.filter !== 'object' || !Object.keys(c.filter).length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_FILTER_REQUIRED */.qj.NODE_FILTER_REQUIRED, at));
+        if (!c.filter || typeof c.filter !== 'object' || !Object.keys(c.filter).length) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_FILTER_REQUIRED */.qj.NODE_FILTER_REQUIRED, at));
         if (c.limit !== undefined && !(Number.isInteger(c.limit) && c.limit >= 1 && c.limit <= _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_WRITE_ITEMS */.Or.MAX_WRITE_ITEMS)) {
-            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_LIMIT_RANGE */.qj.NODE_LIMIT_RANGE, {
+            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_LIMIT_RANGE */.qj.NODE_LIMIT_RANGE, {
                 ...at,
                 max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_WRITE_ITEMS */.Or.MAX_WRITE_ITEMS
             }));
@@ -2983,45 +2327,45 @@ function validateNodeConfig(node, flow, context, err, warn) {
 }
 function childInserts(value, { at, entity, expr, err }) {
     if (value === undefined) return;
-    if (!Array.isArray(value)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHILDREN_INVALID */.qj.NODE_CHILDREN_INVALID, at));
-    if (value.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CHILD_INSERTS */.Or.MAX_CHILD_INSERTS) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHILDREN_TOO_MANY */.qj.NODE_CHILDREN_TOO_MANY, {
+    if (!Array.isArray(value)) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHILDREN_INVALID */.qj.NODE_CHILDREN_INVALID, at));
+    if (value.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CHILD_INSERTS */.Or.MAX_CHILD_INSERTS) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHILDREN_TOO_MANY */.qj.NODE_CHILDREN_TOO_MANY, {
         ...at,
         max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_CHILD_INSERTS */.Or.MAX_CHILD_INSERTS
     }));
     const names = new Set();
     for (const child of value){
         if (!child || typeof child !== 'object') {
-            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHILDREN_INVALID */.qj.NODE_CHILDREN_INVALID, at));
+            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHILDREN_INVALID */.qj.NODE_CHILDREN_INVALID, at));
             continue;
         }
         const name = String(child.as ?? '');
-        if (!_flow_types_js__rspack_import_6/* .FLOW_INPUT_NAME_PATTERN.test */.fZ.test(name)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHILD_NAME_INVALID */.qj.NODE_CHILD_NAME_INVALID, {
+        if (!_flow_types_js__rspack_import_6/* .FLOW_INPUT_NAME_PATTERN.test */.fZ.test(name)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHILD_NAME_INVALID */.qj.NODE_CHILD_NAME_INVALID, {
             ...at,
             name
         }));
-        else if (names.has(name)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHILD_NAME_DUPLICATE */.qj.NODE_CHILD_NAME_DUPLICATE, {
+        else if (names.has(name)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHILD_NAME_DUPLICATE */.qj.NODE_CHILD_NAME_DUPLICATE, {
             ...at,
             name
         }));
         names.add(name);
         entity(child.entityCode);
-        if (typeof child.parentField !== 'string' || !COLUMN_CODE.test(child.parentField)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHILD_PARENT_FIELD_REQUIRED */.qj.NODE_CHILD_PARENT_FIELD_REQUIRED, {
+        if (typeof child.parentField !== 'string' || !COLUMN_CODE.test(child.parentField)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHILD_PARENT_FIELD_REQUIRED */.qj.NODE_CHILD_PARENT_FIELD_REQUIRED, {
             ...at,
             name
         }));
-        expr(child.items, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.CHILD_LIST */.bc.CHILD_LIST, {
+        expr(child.items, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.CHILD_LIST */.bc.CHILD_LIST, {
             name
         }));
         const fields = child.fields;
         if (fields === undefined) continue;
         if (!fields || typeof fields !== 'object' || Array.isArray(fields)) {
-            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_PAIRS_INVALID */.qj.NODE_PAIRS_INVALID, {
+            err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_PAIRS_INVALID */.qj.NODE_PAIRS_INVALID, {
                 ...at,
-                what: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.FIELDS */.bc.FIELDS)
+                what: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.FIELDS */.bc.FIELDS)
             }));
             continue;
         }
-        for (const [key, item] of Object.entries(fields))expr(item, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.CHILD_FIELD */.bc.CHILD_FIELD, {
+        for (const [key, item] of Object.entries(fields))expr(item, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.CHILD_FIELD */.bc.CHILD_FIELD, {
             name: `${name}.${key}`
         }));
     }
@@ -3029,8 +2373,7 @@ function childInserts(value, { at, entity, expr, err }) {
 /**
  * How many loop levels each part of a node's config runs inside, beyond the loops around the node:
  * a foreach's `collect` runs in its own loop; a many / filter write's per-record expressions in one
- * of the node's own; child records one deeper than their parent record; a many message step's values
- * (all but its list) one per item.
+ * of the node's own; child records one deeper than their parent record.
  */ function configScopes(node) {
     const config = node.config ?? {};
     if (node.type === 'foreach') {
@@ -3048,21 +2391,6 @@ function childInserts(value, { at, entity, expr, err }) {
             }
         ];
     }
-    if ((0,_flow_types_js__rspack_import_6/* .isMessageNode */.SE)(node.type) && config['target'] === 'many') {
-        const { items, ...perItem } = config;
-        return [
-            {
-                value: items,
-                extra: 0,
-                ownLoop: false
-            },
-            {
-                value: perItem,
-                extra: 1,
-                ownLoop: false
-            }
-        ];
-    }
     if (!WRITE_NODE_TYPES.has(node.type)) return [
         {
             value: config,
@@ -3101,32 +2429,32 @@ function childInserts(value, { at, entity, expr, err }) {
     return scopes;
 }
 function validateChecks(c, at, rule, err) {
-    if (!Array.isArray(c.checks) || !c.checks.length) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_REQUIRED */.qj.NODE_CHECK_REQUIRED, at));
-    if (c.checks.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_VALIDATE_CHECKS */.Or.MAX_VALIDATE_CHECKS) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_TOO_MANY_CHECKS */.qj.NODE_TOO_MANY_CHECKS, {
+    if (!Array.isArray(c.checks) || !c.checks.length) return err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_REQUIRED */.qj.NODE_CHECK_REQUIRED, at));
+    if (c.checks.length > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_VALIDATE_CHECKS */.Or.MAX_VALIDATE_CHECKS) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_TOO_MANY_CHECKS */.qj.NODE_TOO_MANY_CHECKS, {
         ...at,
         max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_VALIDATE_CHECKS */.Or.MAX_VALIDATE_CHECKS
     }));
     const ids = new Set();
     for (const check of c.checks){
         const id = check?.id;
-        if (typeof id !== 'string' || !CHECK_ID.test(id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_ID_INVALID */.qj.NODE_CHECK_ID_INVALID, {
+        if (typeof id !== 'string' || !CHECK_ID.test(id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_ID_INVALID */.qj.NODE_CHECK_ID_INVALID, {
             ...at,
             name: String(id)
         }));
-        else if (ids.has(id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_ID_DUPLICATE */.qj.NODE_CHECK_ID_DUPLICATE, {
+        else if (ids.has(id)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_ID_DUPLICATE */.qj.NODE_CHECK_ID_DUPLICATE, {
             ...at,
             name: id
         }));
         else ids.add(id);
         const name = String(id);
-        rule(check?.rule, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_SUBJECT_MESSAGES.THE_CHECK */.bc.THE_CHECK, {
+        rule(check?.rule, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_CHECK */.bc.THE_CHECK, {
             name
         }));
-        if (typeof check?.message !== 'string' || !check.message.trim()) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_MESSAGE_REQUIRED */.qj.NODE_CHECK_MESSAGE_REQUIRED, {
+        if (typeof check?.message !== 'string' || !check.message.trim()) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_MESSAGE_REQUIRED */.qj.NODE_CHECK_MESSAGE_REQUIRED, {
             ...at,
             name
         }));
-        if (check?.field !== undefined && (typeof check.field !== 'string' || !check.field.trim() || check.field.length > 100)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_FIELD_INVALID */.qj.NODE_CHECK_FIELD_INVALID, {
+        if (check?.field !== undefined && (typeof check.field !== 'string' || !check.field.trim() || check.field.length > 100)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CHECK_FIELD_INVALID */.qj.NODE_CHECK_FIELD_INVALID, {
             ...at,
             name
         }));
@@ -3147,21 +2475,21 @@ function validateChecks(c, at, rule, err) {
         for (const ref of refs){
             const [scope, second] = ref.split('.');
             if (!REF_SCOPES.has(scope)) {
-                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.REF_BAD_SCOPE */.qj.REF_BAD_SCOPE, {
+                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.REF_BAD_SCOPE */.qj.REF_BAD_SCOPE, {
                     node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(node),
                     ref
                 }));
             } else if (scope === 'context' && second && !byId.has(second)) {
-                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.REF_NODE_MISSING */.qj.REF_NODE_MISSING, {
+                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.REF_NODE_MISSING */.qj.REF_NODE_MISSING, {
                     node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(node),
                     target: second
                 }));
             } else if (scope === 'context' && second === node.id) {
-                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.REF_SELF */.qj.REF_SELF, {
+                err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.REF_SELF */.qj.REF_SELF, {
                     node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(node)
                 }));
             } else if (scope === 'input' && second && namesKnown && !declaredInputs.has(second)) {
-                warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.REF_INPUT_UNDECLARED */.qj.REF_INPUT_UNDECLARED, {
+                warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.REF_INPUT_UNDECLARED */.qj.REF_INPUT_UNDECLARED, {
                     node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(node),
                     input: second
                 }));
@@ -3177,28 +2505,15 @@ function refsOf(value, refs = [], depth = 0) {
     return refs;
 }
 /**
- * Writes that do not share a transaction, and Save progress steps that would not commit: reached
- * from a Request step without the transaction setting, inside a loop (once per item), or in a flow
- * other flows call (inside its caller's transaction it is skipped).
- */ function checkTransactionUse(flow, runs, outgoing, context, warnings) {
-    for (const { endpoint, label, steps } of runs){
-        if (endpoint.isTransactional) continue;
-        const writes = steps.filter((n)=>WRITE_NODE_TYPES.has(n.type)).length;
-        if (writes >= 2) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.WRITES_NOT_TRANSACTIONAL */.qj.WRITES_NOT_TRANSACTIONAL, {
-            count: writes,
-            node: label
-        }));
-        for (const commit of steps)if (commit.type === 'commit') warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.COMMIT_NOT_TRANSACTIONAL */.qj.COMMIT_NOT_TRANSACTIONAL, {
-            node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(commit),
-            endpoint: label
-        }));
-    }
-    const live = [
-        ...new Map(runs.flatMap((run)=>run.steps).map((n)=>[
-                n.id,
-                n
-            ])).values()
-    ];
+ * Writes that do not share a transaction, and Save progress steps that would not commit: in a flow
+ * without the transaction setting, inside a loop (once per item), or in a flow other flows call
+ * (inside its caller's transaction it is skipped).
+ */ function checkTransactionUse(flow, nodes, outgoing, reachable, context, warnings) {
+    const live = nodes.filter((n)=>!reachable || reachable.has(n.id));
+    const writes = live.filter((n)=>WRITE_NODE_TYPES.has(n.type)).length;
+    if (!flow.isTransactional && writes >= 2) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.WRITES_NOT_TRANSACTIONAL */.qj.WRITES_NOT_TRANSACTIONAL, {
+        count: writes
+    }));
     const commits = live.filter((n)=>n.type === 'commit');
     if (!commits.length) return;
     const loops = live.filter((n)=>n.type === 'foreach').map((n)=>({
@@ -3212,12 +2527,13 @@ function refsOf(value, refs = [], depth = 0) {
         const at = {
             node: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(commit)
         };
+        if (!flow.isTransactional) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.COMMIT_NOT_TRANSACTIONAL */.qj.COMMIT_NOT_TRANSACTIONAL, at));
         const loop = loops.find((l)=>l.body.has(commit.id));
-        if (loop) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.COMMIT_IN_LOOP */.qj.COMMIT_IN_LOOP, {
+        if (loop) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.COMMIT_IN_LOOP */.qj.COMMIT_IN_LOOP, {
             ...at,
             loop: (0,_flow_types_js__rspack_import_6/* .nodeLabel */.dA)(loop.node)
         }));
-        if (called) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.COMMIT_IN_CALLED_FLOW */.qj.COMMIT_IN_CALLED_FLOW, at));
+        if (called) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.COMMIT_IN_CALLED_FLOW */.qj.COMMIT_IN_CALLED_FLOW, at));
     }
 }
 /** Every node a loop's `each` branch runs, nested loops included. */ function loopBody(loopId, outgoing) {
@@ -3320,14 +2636,14 @@ function refsOf(value, refs = [], depth = 0) {
                 const [scope, target, field] = segs;
                 if (scope === 'loop') {
                     const parents = segs.slice(1).findIndex((s)=>s !== 'parent');
-                    if (!depth) warn(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.REF_LOOP_OUTSIDE */.qj.REF_LOOP_OUTSIDE, {});
-                    else if ((parents < 0 ? segs.length - 1 : parents) >= depth) warn(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.REF_LOOP_PARENT_MISSING */.qj.REF_LOOP_PARENT_MISSING, {});
+                    if (!depth) warn(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.REF_LOOP_OUTSIDE */.qj.REF_LOOP_OUTSIDE, {});
+                    else if ((parents < 0 ? segs.length - 1 : parents) >= depth) warn(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.REF_LOOP_PARENT_MISSING */.qj.REF_LOOP_PARENT_MISSING, {});
                 }
                 if (scope !== 'context' || !target || target === node.id || !byId.has(target)) continue;
-                if (!available.has(target)) warn(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.REF_NODE_NOT_YET */.qj.REF_NODE_NOT_YET, {
+                if (!available.has(target)) warn(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.REF_NODE_NOT_YET */.qj.REF_NODE_NOT_YET, {
                     target: nameOf(target)
                 });
-                else if (field === 'results' && around.has(target)) warn(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.REF_LOOP_RESULTS_EARLY */.qj.REF_LOOP_RESULTS_EARLY, {
+                else if (field === 'results' && around.has(target)) warn(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.REF_LOOP_RESULTS_EARLY */.qj.REF_LOOP_RESULTS_EARLY, {
                     loop: nameOf(target)
                 });
             }
@@ -3382,15 +2698,14 @@ function reach(start, outgoing) {
         nesting.set(id, max);
         return max;
     };
-    if (nodes.some((n)=>n.type === 'trigger' && nestingFrom(n.id) > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_LOOP_DEPTH */.Or.MAX_LOOP_DEPTH)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_8/* .FLOW_VALIDATION_MESSAGES.LOOP_TOO_DEEP */.qj.LOOP_TOO_DEEP, {
+    if (nodes.some((n)=>n.type === 'trigger' && nestingFrom(n.id) > _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_LOOP_DEPTH */.Or.MAX_LOOP_DEPTH)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.LOOP_TOO_DEEP */.qj.LOOP_TOO_DEEP, {
         max: _flow_types_js__rspack_import_6/* .FLOW_LIMITS.MAX_LOOP_DEPTH */.Or.MAX_LOOP_DEPTH
     }));
 }
 
 __webpack_require__.d(__webpack_exports__, {
-  nC: () => (validateFlow),
-  r7: () => (callProblems),
-  u9: () => (usesPermissionFunction)
+  n: () => (validateFlow),
+  u: () => (usesPermissionFunction)
 });
 
 
@@ -3680,7 +2995,6 @@ const FLOW_NODE_TYPES = [
     'trigger',
     'validate',
     'permission_check',
-    'company_branch_check',
     'set',
     'condition',
     'switch',
@@ -3694,32 +3008,21 @@ const FLOW_NODE_TYPES = [
     'call_flow',
     'http_request',
     'publish_event',
-    'send_notification',
-    'send_email',
     'respond',
     'code'
 ];
 /** A failure of these always ends the run: checks can never be carried past, and Save progress cannot run in a savepoint. */ const NON_CONTINUABLE_NODE_TYPES = new Set([
     'validate',
     'permission_check',
-    'company_branch_check',
     'commit'
 ]);
-/**
- * Who may start a run at a Request step. `internal` (other flows only): the step has no URL - only
- * other flows' `call_flow` steps start there, and the run takes its caller's run-as.
- */ const FLOW_AUTH_MODES = [
+const FLOW_AUTH_MODES = [
     'public',
     'api_key',
     'jwt',
     'permission',
     'internal'
 ];
-/** A Request step that sets no access: any signed-in user. */ const DEFAULT_AUTH_MODE = 'jwt';
-/** Modes a caller reaches without signing in: the run has no `user`. */ const KEYLESS_AUTH_MODES = new Set([
-    'public',
-    'api_key'
-]);
 const FLOW_RUN_AS = [
     'caller',
     'system'
@@ -3752,42 +3055,6 @@ const FLOW_INPUT_TYPES = [
     'many',
     'filter'
 ];
-function isStoredApiKey(value) {
-    const key = value;
-    return typeof key?.prefix === 'string' && typeof key.hash === 'string' && /^[0-9a-f]{64}$/.test(key.hash);
-}
-/** The app modules a message step sends through; a step whose module is not installed cannot be saved or run. */ const FLOW_MESSAGE_SERVICES = {
-    send_notification: 'notification',
-    send_email: 'email'
-};
-const isMessageNode = (type)=>Object.hasOwn(FLOW_MESSAGE_SERVICES, type);
-const FLOW_NOTIFICATION_TYPES = [
-    'info',
-    'success',
-    'warning',
-    'error'
-];
-/**
- * Who a notification step sends to. one (default): one notification to the users `userIds` names.
- * many: one per item of `items`, each read with the item as `loop.item`. company: every active member
- * of `companyIds` (one or a list; with `branchIds`, only those also in one of those branches), shown under that company.
- */ const FLOW_NOTIFICATION_TARGETS = [
-    'one',
-    'many',
-    'company'
-];
-/** one (default): one email. many: one per item of `items`, each read with the item as `loop.item`. */ const FLOW_EMAIL_TARGETS = [
-    'one',
-    'many'
-];
-const FLOW_EMAIL_MODES = [
-    'content',
-    'template'
-];
-const FLOW_EMAIL_FORMATS = [
-    'text',
-    'html'
-];
 const FLOW_LIMITS = {
     MAX_NODES: 100,
     MAX_EDGES: 300,
@@ -3796,13 +3063,6 @@ const FLOW_LIMITS = {
     MAX_LOOP_DEPTH: 3,
     MAX_CALL_DEPTH: 5,
     MAX_HTTP_CALLS: 10,
-    /** Notification and email steps sent per run (a loop counts every pass). */ MAX_MESSAGES_PER_RUN: 100,
-    MAX_NOTIFICATION_RECIPIENTS: 500,
-    /** All members of the companies a company-wide notification step reaches. */ MAX_COMPANY_NOTIFICATION_RECIPIENTS: 5000,
-    /** to + cc + bcc of one email. */ MAX_EMAIL_RECIPIENTS: 50,
-    MAX_NOTIFICATION_TITLE_LENGTH: 255,
-    MAX_EMAIL_SUBJECT_LENGTH: 255,
-    MAX_EMAIL_TEMPLATE_SLUG_LENGTH: 255,
     MAX_HTTP_TIMEOUT_MS: 15_000,
     MAX_HTTP_RESPONSE_BYTES: 1_000_000,
     MAX_QUERY_LIMIT: 200,
@@ -3813,8 +3073,6 @@ const FLOW_LIMITS = {
     DEFAULT_TIMEOUT_MS: 30_000,
     MIN_TIMEOUT_MS: 1000,
     MAX_TIMEOUT_MS: 120_000,
-    DEFAULT_RATE_LIMIT_PER_MINUTE: 60,
-    MAX_RATE_LIMIT_PER_MINUTE: 100_000,
     TRACE_PREVIEW_CHARS: 2000,
     MAX_INPUT_FIELDS: 50,
     /** How deep object/list-of-object fields may nest inside the request body. */ MAX_INPUT_DEPTH: 4,
@@ -3833,38 +3091,25 @@ const FLOW_NODE_ID_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,39}$/;
 const FLOW_SLUG_PATTERN = /^[a-z][a-z0-9-]{2,62}$/;
 const FLOW_INPUT_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,59}$/;
 const FLOW_ENDPOINT_PATH_PATTERN = /^[a-z][a-z0-9-]{0,62}$/;
-/** A record, user or company id. */ const FLOW_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/** Who may start a run at a Request step; an unknown mode reads as the default, which the validator refuses on save. */ function endpointAuth(config) {
-    const authMode = config.authMode && FLOW_AUTH_MODES.includes(config.authMode) ? config.authMode : DEFAULT_AUTH_MODE;
-    const code = authMode === 'permission' && typeof config.permissionCode === 'string' ? config.permissionCode.trim() : '';
-    return {
-        authMode,
-        permissionCode: code || null
-    };
-}
-/** A flow whose every Request step is `internal`: a function, with no URL of its own. */ const isFunctionFlow = (flow)=>{
-    const endpoints = flowEndpoints(flow);
-    return endpoints.length > 0 && endpoints.every((endpoint)=>endpoint.authMode === 'internal');
-};
 /** A Request step's path, or null when it answers on the flow's own URL. */ function triggerPath(node) {
     const path = node.config?.path;
     return typeof path === 'string' && path.trim() ? path.trim() : null;
 }
-/** Every Request step of a flow as a URL, with the body and access it sets. */ function flowEndpoints(flow) {
+/** Every Request step of a flow as a URL. */ function flowEndpoints(flow) {
     return (flow.nodes ?? []).filter((node)=>node?.type === 'trigger').map((node)=>{
         const path = triggerPath(node);
-        const config = node.config ?? {};
+        if (!path) return {
+            nodeId: node.id,
+            path,
+            bodyType: flow.bodyType ?? 'object',
+            inputSchema: flow.inputSchema ?? []
+        };
+        const config = node.config;
         return {
             nodeId: node.id,
             path,
             bodyType: config.bodyType ?? 'object',
-            inputSchema: Array.isArray(config.inputSchema) ? config.inputSchema : [],
-            ...endpointAuth(config),
-            runAs: config.runAs ?? 'caller',
-            isTransactional: config.isTransactional === true,
-            timeoutMs: config.timeoutMs ?? FLOW_LIMITS.DEFAULT_TIMEOUT_MS,
-            rateLimitPerMinute: config.rateLimitPerMinute ?? FLOW_LIMITS.DEFAULT_RATE_LIMIT_PER_MINUTE,
-            apiKey: isStoredApiKey(config.apiKey) ? config.apiKey : null
+            inputSchema: Array.isArray(config.inputSchema) ? config.inputSchema : []
         };
     });
 }
@@ -3872,9 +3117,6 @@ const FLOW_ENDPOINT_PATH_PATTERN = /^[a-z][a-z0-9-]{0,62}$/;
     const wanted = path?.trim() || null;
     return flowEndpoints(flow).find((endpoint)=>endpoint.path === wanted);
 }
-/** The Request step a run starts at: by its id, or the one on the flow's own URL when none is named. */ function startEndpoint(flow, nodeId) {
-    return nodeId ? flowEndpoints(flow).find((endpoint)=>endpoint.nodeId === nodeId) : findEndpoint(flow);
-}
 /** Output ports a node of this type can have (a `respond` node ends the flow: none). */ function portsOf(node) {
     switch(node.type){
         case 'condition':
@@ -3893,7 +3135,6 @@ const FLOW_ENDPOINT_PATH_PATTERN = /^[a-z][a-z0-9-]{0,62}$/;
                 'done'
             ];
         case 'permission_check':
-        case 'company_branch_check':
             return node.config.onDenied === 'branch' ? [
                 'allowed',
                 'denied'
@@ -3918,35 +3159,23 @@ const FLOW_ENDPOINT_PATH_PATTERN = /^[a-z][a-z0-9-]{0,62}$/;
 }
 
 __webpack_require__.d(__webpack_exports__, {
-  IE: () => (startEndpoint),
   Xr: () => (flowEndpoints),
   a5: () => (portsOf),
   um: () => (triggerPath),
-  vS: () => (findEndpoint),
-  xA: () => (isStoredApiKey)
+  vS: () => (findEndpoint)
 }, {
   At: NON_CONTINUABLE_NODE_TYPES,
-  B9: FLOW_EMAIL_TARGETS,
   Dn: RECORD_WRITE_TARGETS,
-  E2: FLOW_ID_PATTERN,
-  FU: FLOW_EMAIL_FORMATS,
-  KF: FLOW_MESSAGE_SERVICES,
-  LG: FLOW_NOTIFICATION_TYPES,
   Or: FLOW_LIMITS,
   Q7: FLOW_INPUT_TYPES,
-  SE: isMessageNode,
   Y3: FLOW_BODY_TYPES,
   YD: FLOW_SLUG_PATTERN,
   YO: FLOW_ENDPOINT_PATH_PATTERN,
-  as: FLOW_NOTIFICATION_TARGETS,
-  d7: KEYLESS_AUTH_MODES,
   dA: nodeLabel,
   fO: FLOW_AUTH_MODES,
-  fP: isFunctionFlow,
   fZ: FLOW_INPUT_NAME_PATTERN,
   gl: FLOW_RUN_AS,
   q2: FLOW_NODE_TYPES,
-  v1: FLOW_EMAIL_MODES,
   z6: FLOW_NODE_ID_PATTERN
 });
 
@@ -3957,8 +3186,6 @@ const SENSITIVE_KEY = /pass(word)?|secret|token|authorization|api[-_]?key|cookie
 /** Copy of `value` with the content of sensitive-looking keys replaced, safe to store in a log. */ function redactSensitive(value, depth = 0) {
     if (depth > 8) return '[deep]';
     if (Array.isArray(value)) return value.slice(0, 100).map((v)=>redactSensitive(v, depth + 1));
-    // Dates (and anything else with its own JSON form) have no own keys: walked as objects they would log as `{}`.
-    if (value && typeof value.toJSON === 'function') return redactSensitive(value.toJSON(), depth + 1);
     if (value && typeof value === 'object') {
         const out = {};
         for (const [key, item] of Object.entries(value)){
@@ -4613,61 +3840,54 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 },
-4921(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+8888(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  Tk: () => (/* binding */ FlowDefinitionService),
-  Er: () => (/* binding */ defaultFlowPermissionCode),
-  YW: () => (/* binding */ flowNotFound),
-  HF: () => (/* binding */ isPublished),
-  eY: () => (/* binding */ snapshotOf),
-  RK: () => (/* binding */ toFlowSettings),
-  lw: () => (/* binding */ workingCopy)
+  T: () => (/* binding */ FlowApiKeyService)
 });
 
-// EXTERNAL MODULE: external "@flusys/nestjs-shared"
-var nestjs_shared_ = __webpack_require__(3422);
-// EXTERNAL MODULE: external "@flusys/nestjs-shared/classes"
-var classes_ = __webpack_require__(6937);
-// EXTERNAL MODULE: external "@flusys/nestjs-shared/interfaces"
-var interfaces_ = __webpack_require__(5103);
-// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
-var modules_ = __webpack_require__(1236);
 // EXTERNAL MODULE: external "@nestjs/common"
 var common_ = __webpack_require__(6157);
 // EXTERNAL MODULE: external "typeorm"
 var external_typeorm_ = __webpack_require__(7158);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/event-actions.ts
-var event_actions = __webpack_require__(982);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/message-keys.ts
 var message_keys = __webpack_require__(5732);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/entities/entity-definition.entity.ts
-var entity_definition_entity = __webpack_require__(3189);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/entities/flow-api-key.entity.ts
+var flow_api_key_entity = __webpack_require__(201);
+// EXTERNAL MODULE: external "node:crypto"
+var external_node_crypto_ = __webpack_require__(2561);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-api-key.ts
+
+const API_KEY_PREFIX_LENGTH = 11; // "fk_" + 8 hex
+/** A new key: `fk_<8 hex>_<32 hex>`. Shown once; only its hash is stored. */ function generateApiKey() {
+    const key = `fk_${(0,external_node_crypto_.randomBytes)(4).toString('hex')}_${(0,external_node_crypto_.randomBytes)(16).toString('hex')}`;
+    return {
+        key,
+        prefix: apiKeyPrefix(key),
+        hash: hashApiKey(key)
+    };
+}
+const hashApiKey = (key)=>(0,external_node_crypto_.createHash)('sha256').update(key).digest('hex');
+const apiKeyPrefix = (key)=>key.slice(0, API_KEY_PREFIX_LENGTH);
+function looksLikeApiKey(key) {
+    return typeof key === 'string' && /^fk_[0-9a-f]{8}_[0-9a-f]{32}$/.test(key);
+}
+/** Constant-time comparison of a presented key against a stored hash. */ function apiKeyMatches(presented, storedHash) {
+    const a = Buffer.from(hashApiKey(presented), 'hex');
+    const b = Buffer.from(storedHash, 'hex');
+    return a.length === b.length && (0,external_node_crypto_.timingSafeEqual)(a, b);
+}
+
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/entities/flow-definition.entity.ts
 var flow_definition_entity = __webpack_require__(3770);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/entities/flow-version.entity.ts
-var flow_version_entity = __webpack_require__(2399);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-api-key.ts
-var flow_api_key = __webpack_require__(4816);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-graph.validator.ts
-var flow_graph_validator = __webpack_require__(3186);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow.types.ts
-var flow_types = __webpack_require__(6256);
-;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/interfaces/flow-definition.interface.ts
-/** What a version holds and a draft edits: everything about a flow but its identity. */ const FLOW_VERSIONED_FIELDS = [
-    'name',
-    'slug',
-    'description',
-    'isActive',
-    'retainExecutions',
-    'nodes',
-    'edges'
-];
-
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-values.ts
+var rule_values = __webpack_require__(6622);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-builder-datasource.provider.ts
 var entity_builder_datasource_provider = __webpack_require__(424);
-;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts
+var flow_definition_service = __webpack_require__(5229);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/services/flow-api-key.service.ts
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -4700,6 +3920,195 @@ function _ts_param(paramIndex, decorator) {
 
 
 
+const TOUCH_INTERVAL_MS = 60_000;
+class FlowApiKeyService {
+    provider;
+    constructor(provider){
+        this.provider = provider;
+    }
+    async repo() {
+        return this.provider.getRepository(flow_api_key_entity/* .FlowApiKey */.S);
+    }
+    async assertFlowExists(flowId) {
+        const flow = await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).findOne({
+            where: {
+                id: flowId
+            },
+            select: {
+                id: true
+            }
+        });
+        if (!flow) throw (0,flow_definition_service/* .flowNotFound */.YW)();
+    }
+    async findKey(id) {
+        const key = await (await this.repo()).findOne({
+            where: {
+                id
+            }
+        });
+        if (!key) throw new common_.NotFoundException({
+            message: 'API key not found.',
+            messageKey: message_keys/* .FLOW_MESSAGES.API_KEY_NOT_FOUND */.wu.API_KEY_NOT_FOUND
+        });
+        await this.assertFlowExists(key.flowId);
+        return key;
+    }
+    /** The plain key is returned here and never again. */ async create(flowId, name, expiresAt, user) {
+        const expiry = expiresAt ? (0,rule_values/* .parseDateText */.hz)(expiresAt) : null;
+        if (expiry !== null && !(expiry > Date.now())) {
+            throw new common_.BadRequestException({
+                message: 'The expiry date of an API key must be in the future.',
+                messageKey: message_keys/* .FLOW_MESSAGES.API_KEY_EXPIRY_IN_PAST */.wu.API_KEY_EXPIRY_IN_PAST
+            });
+        }
+        await this.assertFlowExists(flowId);
+        const { key, prefix, hash } = generateApiKey();
+        const repo = await this.repo();
+        const saved = await repo.save(repo.create({
+            flowId,
+            name,
+            keyPrefix: prefix,
+            keyHash: hash,
+            isActive: true,
+            expiresAt: expiry === null ? null : new Date(expiry),
+            lastUsedAt: null,
+            createdById: user?.id ?? null
+        }));
+        return {
+            key,
+            info: this.info(saved)
+        };
+    }
+    async list(flowId) {
+        await this.assertFlowExists(flowId);
+        const rows = await (await this.repo()).find({
+            where: {
+                flowId
+            },
+            order: {
+                createdAt: 'DESC'
+            }
+        });
+        return rows.map((r)=>this.info(r));
+    }
+    async revoke(id) {
+        const key = await this.findKey(id);
+        await (await this.repo()).update({
+            id: key.id
+        }, {
+            isActive: false
+        });
+    }
+    async remove(id) {
+        const key = await this.findKey(id);
+        await (await this.repo()).softDelete({
+            id: key.id
+        });
+    }
+    /**
+   * Checks `presented` against the unrevoked keys of this flow. Only the flow access guard calls
+   * this, and only while the flow's authMode is `api_key`; revoking works in any authMode.
+   */ async verify(flowId, presented) {
+        if (!looksLikeApiKey(presented)) return 'invalid';
+        const repo = await this.repo();
+        const candidates = await repo.find({
+            where: {
+                flowId,
+                keyPrefix: apiKeyPrefix(presented),
+                isActive: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            },
+            select: {
+                id: true,
+                keyHash: true,
+                expiresAt: true,
+                lastUsedAt: true
+            }
+        });
+        const match = candidates.find((c)=>apiKeyMatches(presented, c.keyHash));
+        if (!match) return 'invalid';
+        if (isExpired(match.expiresAt)) return 'expired';
+        if (!match.lastUsedAt || Date.now() - match.lastUsedAt.getTime() > TOUCH_INTERVAL_MS) {
+            await repo.update({
+                id: match.id
+            }, {
+                lastUsedAt: new Date()
+            });
+        }
+        return 'valid';
+    }
+    info(row) {
+        const status = !row.isActive ? 'revoked' : isExpired(row.expiresAt) ? 'expired' : 'active';
+        return {
+            id: row.id,
+            flowId: row.flowId,
+            name: row.name,
+            keyPrefix: row.keyPrefix,
+            isActive: row.isActive,
+            status,
+            expiresAt: row.expiresAt,
+            lastUsedAt: row.lastUsedAt,
+            createdAt: row.createdAt
+        };
+    }
+}
+FlowApiKeyService = _ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    _ts_param(0, (0,common_.Inject)(entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D
+    ])
+], FlowApiKeyService);
+function isExpired(expiresAt) {
+    return !!expiresAt && expiresAt.getTime() <= Date.now();
+}
+
+
+},
+5229(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared__rspack_import_0 = __webpack_require__(3422);
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_1 = __webpack_require__(6937);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_2 = __webpack_require__(1236);
+/* import */ var _nestjs_common__rspack_import_3 = __webpack_require__(6157);
+/* import */ var typeorm__rspack_import_4 = __webpack_require__(7158);
+/* import */ var _config_event_actions_js__rspack_import_11 = __webpack_require__(982);
+/* import */ var _config_message_keys_js__rspack_import_10 = __webpack_require__(5732);
+/* import */ var _entities_entity_definition_entity_js__rspack_import_5 = __webpack_require__(3189);
+/* import */ var _entities_flow_definition_entity_js__rspack_import_6 = __webpack_require__(3770);
+/* import */ var _flow_engine_flow_graph_validator_js__rspack_import_7 = __webpack_require__(3186);
+/* import */ var _flow_engine_flow_types_js__rspack_import_8 = __webpack_require__(6256);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_9 = __webpack_require__(424);
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
 
 
 
@@ -4708,44 +4117,34 @@ function _ts_param(paramIndex, decorator) {
 
 
 const defaultFlowPermissionCode = (slug)=>`entity_builder.flow.${slug}.execute`;
-const flowNotFound = ()=>new common_.NotFoundException({
+const flowNotFound = ()=>new _nestjs_common__rspack_import_3.NotFoundException({
         message: 'Flow not found.',
-        messageKey: message_keys/* .FLOW_MESSAGES.NOT_FOUND */.wu.NOT_FOUND
-    });
-/** A flow that has been published at least once: its columns are what callers run. */ const isPublished = (flow)=>flow.version > 0;
-/** The versioned part of a flow (or of a draft), in a fixed key order so two snapshots compare as text. */ function snapshotOf(source) {
-    return Object.fromEntries(FLOW_VERSIONED_FIELDS.filter((key)=>source[key] !== undefined).map((key)=>[
-            key,
-            source[key]
-        ]));
-}
-const sameSnapshot = (a, b)=>JSON.stringify(a) === JSON.stringify(b);
-/** What the designer edits: the saved draft, or the published flow when there is none. */ const workingCopy = (flow)=>({
-        ...snapshotOf(flow),
-        ...flow.draft
+        messageKey: _config_message_keys_js__rspack_import_10/* .FLOW_MESSAGES.NOT_FOUND */.wu.NOT_FOUND
     });
-/** What running a flow needs; everything about a run is on its Request steps. */ function toFlowSettings(dto) {
+/** Fills the defaults a flow definition gets when a field is left out. */ function toFlowSettings(dto) {
     return {
         slug: dto.slug,
+        authMode: dto.authMode ?? 'jwt',
+        runAs: dto.runAs ?? 'caller',
+        isTransactional: dto.isTransactional ?? false,
+        bodyType: dto.bodyType ?? 'object',
+        inputSchema: dto.inputSchema ?? [],
         nodes: dto.nodes ?? [],
-        edges: dto.edges ?? []
+        edges: dto.edges ?? [],
+        timeoutMs: dto.timeoutMs ?? _flow_engine_flow_types_js__rspack_import_8/* .FLOW_LIMITS.DEFAULT_TIMEOUT_MS */.Or.DEFAULT_TIMEOUT_MS
     };
 }
-/** A Request step with a URL that runs as the system (an `internal` one runs as its caller, whatever it says). */ const runsAsSystem = (settings)=>(0,flow_types/* .flowEndpoints */.Xr)(settings).some((endpoint)=>endpoint.authMode !== 'internal' && endpoint.runAs === 'system');
-class FlowDefinitionService extends classes_.ApiService {
+class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import_1.ApiService {
     cacheManager;
     utilsService;
     provider;
     permissionCache;
     actionRegistry;
-    notifications;
-    email;
-    companyAccess;
-    constructor(cacheManager, utilsService, provider, permissionCache, actionRegistry, notifications, email, companyAccess){
-        super(event_actions/* .ENTITY_BUILDER_EVENT_ENTITIES.FLOW_DEFINITION */.P.FLOW_DEFINITION, cacheManager, utilsService, FlowDefinitionService.name, true, event_actions/* .ENTITY_BUILDER_EVENT_MODULE */.S, provider, flow_definition_entity/* .FlowDefinition */.G), this.cacheManager = cacheManager, this.utilsService = utilsService, this.provider = provider, this.permissionCache = permissionCache, this.actionRegistry = actionRegistry, this.notifications = notifications, this.email = email, this.companyAccess = companyAccess;
+    constructor(cacheManager, utilsService, provider, permissionCache, actionRegistry){
+        super(_config_event_actions_js__rspack_import_11/* .ENTITY_BUILDER_EVENT_ENTITIES.FLOW_DEFINITION */.P.FLOW_DEFINITION, cacheManager, utilsService, FlowDefinitionService.name, true, _config_event_actions_js__rspack_import_11/* .ENTITY_BUILDER_EVENT_MODULE */.S, provider, _entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G), this.cacheManager = cacheManager, this.utilsService = utilsService, this.provider = provider, this.permissionCache = permissionCache, this.actionRegistry = actionRegistry;
     }
     async findOrFail(id) {
-        const flow = await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).findOne({
+        const flow = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G)).findOne({
             where: {
                 id
             }
@@ -4753,28 +4152,28 @@ class FlowDefinitionService extends classes_.ApiService {
         if (!flow) throw flowNotFound();
         return flow;
     }
-    /** Validation with the real entity and flow lists and the modules this app runs. Returns errors and warnings without throwing. */ async validate(settings) {
-        const entities = await (await this.provider.getRepository(entity_definition_entity/* .EntityDefinition */.f)).find({
+    /** Validation with the real entity and flow lists. Returns errors and warnings without throwing. */ async validate(settings) {
+        const entities = await (await this.provider.getRepository(_entities_entity_definition_entity_js__rspack_import_5/* .EntityDefinition */.f)).find({
             select: {
                 code: true
             }
         });
-        const flows = await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).find();
-        return (0,flow_graph_validator/* .validateFlow */.nC)(settings, {
+        const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G)).find();
+        return (0,_flow_engine_flow_graph_validator_js__rspack_import_7/* .validateFlow */.n)(settings, {
             knownEntityCodes: new Set(entities.map((e)=>e.code)),
             knownFlows: new Map(flows.map((flow)=>[
                     flow.slug,
-                    callableOf(flow)
-                ])),
-            messageServices: {
-                notification: !!this.notifications,
-                email: !!this.email
-            },
-            companyMembers: !!this.companyAccess
+                    {
+                        isActive: flow.isActive,
+                        authMode: flow.authMode,
+                        endpoints: (0,_flow_engine_flow_types_js__rspack_import_8/* .flowEndpoints */.Xr)(flow),
+                        calls: calledSlugs(flow.nodes)
+                    }
+                ]))
         });
     }
     /** Names of the other flows whose `call_flow` nodes run `slug`. */ async callersOf(slug, excludeIds) {
-        const flows = await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).find({
+        const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G)).find({
             select: {
                 id: true,
                 name: true,
@@ -4786,83 +4185,20 @@ class FlowDefinitionService extends classes_.ApiService {
     async assertNotCalled(slug, excludeIds) {
         const callers = await this.callersOf(slug, excludeIds);
         if (!callers.length) return;
-        throw new common_.ConflictException({
+        throw new _nestjs_common__rspack_import_3.ConflictException({
             message: `The flow '${slug}' is called by: ${callers.join(', ')}. Change those flows first.`,
-            messageKey: message_keys/* .FLOW_MESSAGES.CALLED_BY_OTHER_FLOWS */.wu.CALLED_BY_OTHER_FLOWS,
+            messageKey: _config_message_keys_js__rspack_import_10/* .FLOW_MESSAGES.CALLED_BY_OTHER_FLOWS */.wu.CALLED_BY_OTHER_FLOWS,
             messageVariables: {
                 slug,
                 flows: callers.join(', ')
             }
         });
     }
-    /**
-   * Other flows' Call flow steps keep working: the URL name they call is not renamed, the paths they
-   * start at are not dropped, and nothing else they rely on changes under them - access, body,
-   * required inputs, the flow staying on, the call chain staying loop-free and within depth.
-   */ async assertCallersKept(before, after, live) {
-        if (after.slug !== before.slug) return this.assertNotCalled(before.slug, [
-            before.id
-        ]);
-        await this.assertEndpointsNotCalled(before, after);
-        await this.assertCallsStillValid(before, {
-            ...after,
-            ...live
-        });
-    }
-    /**
-   * Checks each running flow that calls this one, directly or through other flows, against the flows
-   * as they are and as this change leaves them, and refuses the change when it adds a problem. A
-   * caller already broken for another reason does not block it; only what this change breaks does.
-   */ async assertCallsStillValid(before, after) {
-        const flows = await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).find();
-        const running = flows.filter((flow)=>flow.id !== before.id && flow.isActive && isPublished(flow) && calledSlugs(flow.nodes).length);
-        if (!running.length) return;
-        const now = new Map(flows.map((flow)=>[
-                flow.slug,
-                callableOf(flow)
-            ]));
-        const next = new Map(now).set(before.slug, callableOf(after));
-        const broken = [];
-        for (const caller of running){
-            const settings = toFlowSettings(caller);
-            // Counted, not a set: two steps with the same label can share a problem, and only the new one is added.
-            const existing = new Map();
-            for (const problem of (0,flow_graph_validator/* .callProblems */.r7)(settings, before.slug, now)){
-                const key = JSON.stringify(problem);
-                existing.set(key, (existing.get(key) ?? 0) + 1);
-            }
-            const added = (0,flow_graph_validator/* .callProblems */.r7)(settings, before.slug, next).filter((problem)=>{
-                const key = JSON.stringify(problem);
-                const left = existing.get(key) ?? 0;
-                existing.set(key, left - 1);
-                return left <= 0;
-            });
-            if (added.length) broken.push({
-                flow: caller.name,
-                problems: added
-            });
-        }
-        if (!broken.length) return;
-        const names = broken.map((b)=>b.flow).join(', ');
-        throw new common_.ConflictException({
-            message: `This change breaks flows that call '${before.slug}': ${names}. Change those flows first.`,
-            messageKey: message_keys/* .FLOW_MESSAGES.CALLERS_BROKEN */.wu.CALLERS_BROKEN,
-            messageVariables: {
-                slug: before.slug,
-                flows: names
-            },
-            errors: broken.flatMap((b)=>b.problems.map((problem)=>({
-                        field: 'flow',
-                        flow: b.flow,
-                        ...problem
-                    })))
-        });
-    }
     /** A URL other flows' Call flow steps start at cannot be removed or renamed from under them. */ async assertEndpointsNotCalled(before, after) {
-        const kept = new Set((0,flow_types/* .flowEndpoints */.Xr)(after).map((e)=>e.path));
-        const removed = (0,flow_types/* .flowEndpoints */.Xr)(before).map((e)=>e.path).filter((path)=>!kept.has(path));
+        const kept = new Set((0,_flow_engine_flow_types_js__rspack_import_8/* .flowEndpoints */.Xr)(after).map((e)=>e.path));
+        const removed = (0,_flow_engine_flow_types_js__rspack_import_8/* .flowEndpoints */.Xr)(before).map((e)=>e.path).filter((path)=>!kept.has(path));
         if (!removed.length) return;
-        const flows = await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).find({
+        const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G)).find({
             select: {
                 id: true,
                 name: true,
@@ -4873,9 +4209,9 @@ class FlowDefinitionService extends classes_.ApiService {
             const callers = flows.filter((flow)=>flow.id !== before.id && calledTargets(flow.nodes).some((t)=>t.slug === before.slug && t.endpoint === path)).map((flow)=>flow.name);
             if (!callers.length) continue;
             const url = `api-flows/${before.slug}${path ? `/${path}` : ''}`;
-            throw new common_.ConflictException({
+            throw new _nestjs_common__rspack_import_3.ConflictException({
                 message: `The URL ${url} is called by: ${callers.join(', ')}. Change those flows first.`,
-                messageKey: message_keys/* .FLOW_MESSAGES.ENDPOINT_CALLED_BY_OTHER_FLOWS */.wu.ENDPOINT_CALLED_BY_OTHER_FLOWS,
+                messageKey: _config_message_keys_js__rspack_import_10/* .FLOW_MESSAGES.ENDPOINT_CALLED_BY_OTHER_FLOWS */.wu.ENDPOINT_CALLED_BY_OTHER_FLOWS,
                 messageVariables: {
                     url,
                     flows: callers.join(', ')
@@ -4886,9 +4222,9 @@ class FlowDefinitionService extends classes_.ApiService {
     async assertSaveable(settings, user, selfId) {
         const { errors, warnings } = await this.validate(settings);
         if (errors.length) {
-            throw new common_.BadRequestException({
+            throw new _nestjs_common__rspack_import_3.BadRequestException({
                 message: 'The flow has problems.',
-                messageKey: message_keys/* .FLOW_MESSAGES.INVALID */.wu.INVALID,
+                messageKey: _config_message_keys_js__rspack_import_10/* .FLOW_MESSAGES.INVALID */.wu.INVALID,
                 errors: errors.map((error)=>({
                         field: 'flow',
                         ...error
@@ -4896,16 +4232,16 @@ class FlowDefinitionService extends classes_.ApiService {
                 warnings
             });
         }
-        const clash = await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).findOne({
+        const clash = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G)).findOne({
             where: {
                 slug: settings.slug
             },
             withDeleted: true
         });
         if (clash && clash.id !== selfId) {
-            throw new common_.ConflictException({
+            throw new _nestjs_common__rspack_import_3.ConflictException({
                 message: `The URL name '${settings.slug}' is already used by another flow.`,
-                messageKey: message_keys/* .FLOW_MESSAGES.SLUG_TAKEN */.wu.SLUG_TAKEN,
+                messageKey: _config_message_keys_js__rspack_import_10/* .FLOW_MESSAGES.SLUG_TAKEN */.wu.SLUG_TAKEN,
                 messageVariables: {
                     slug: settings.slug
                 }
@@ -4914,21 +4250,21 @@ class FlowDefinitionService extends classes_.ApiService {
         await this.assertMayAuthor(settings, user);
     }
     /** The extra permissions a flow needs from whoever writes it: saving it, or test-running it as an unsaved draft. */ async assertMayAuthor(settings, user) {
-        if (runsAsSystem(settings)) await this.assertHasPermission(user, nestjs_shared_.FLOW_DEFINITION_PERMISSIONS.SYSTEM);
-        if (settings.nodes.some((node)=>node?.type === 'code')) await this.assertHasPermission(user, nestjs_shared_.FLOW_DEFINITION_PERMISSIONS.CODE);
+        if (settings.runAs === 'system') await this.assertHasPermission(user, _flusys_nestjs_shared__rspack_import_0.FLOW_DEFINITION_PERMISSIONS.SYSTEM);
+        if (settings.nodes.some((node)=>node?.type === 'code')) await this.assertHasPermission(user, _flusys_nestjs_shared__rspack_import_0.FLOW_DEFINITION_PERMISSIONS.CODE);
     }
     async assertMayCreate(user) {
-        await this.assertHasPermission(user, nestjs_shared_.FLOW_DEFINITION_PERMISSIONS.CREATE);
+        await this.assertHasPermission(user, _flusys_nestjs_shared__rspack_import_0.FLOW_DEFINITION_PERMISSIONS.CREATE);
     }
     /**
    * A test run needs what running the flow for real would: the author permissions for its
    * run-as and code nodes (a saved flow as much as a draft). A live run also needs what makes it
-   * real - a draft the permission to save it, a permission URL its own execute permission.
-   */ async assertMayTest(settings, endpoint, user, run) {
+   * real - a draft the permission to save it, a permission flow its own execute permission.
+   */ async assertMayTest(settings, user, run) {
         await this.assertMayAuthor(settings, user);
         if (run.mode !== 'live') return;
-        if (run.draft) await this.assertHasPermission(user, run.saved ? nestjs_shared_.FLOW_DEFINITION_PERMISSIONS.UPDATE : nestjs_shared_.FLOW_DEFINITION_PERMISSIONS.CREATE);
-        if (endpoint?.authMode === 'permission') await this.assertHasPermission(user, endpoint.permissionCode || defaultFlowPermissionCode(settings.slug));
+        if (run.draft) await this.assertHasPermission(user, run.saved ? _flusys_nestjs_shared__rspack_import_0.FLOW_DEFINITION_PERMISSIONS.UPDATE : _flusys_nestjs_shared__rspack_import_0.FLOW_DEFINITION_PERMISSIONS.CREATE);
+        if (settings.authMode === 'permission') await this.assertHasPermission(user, settings.permissionCode || defaultFlowPermissionCode(settings.slug));
     }
     assertHasPermission(user, permission) {
         return this.permissionCache.assertPermission(user, permission);
@@ -4938,187 +4274,37 @@ class FlowDefinitionService extends classes_.ApiService {
             dto
         ]){
             await this.assertSaveable(toFlowSettings(d), user);
-            d.nodes = (0,flow_api_key/* .sealApiKeys */.ue)(d.nodes);
-            d.version = 0;
+            // JSON columns have no database default, so leaving the optional settings out must not mean NULL.
+            d.inputSchema ??= [];
+            d.bodyType ??= 'object';
+            d.authMode ??= 'jwt';
+            d.runAs ??= 'caller';
         }
     }
-    /**
-   * Checked against what the save produces: the draft of a published flow, the flow itself before its
-   * first publish. An unpublished flow changes in place, so its callers are protected now, not at publish.
-   */ async beforeUpdateOperation(dto, user, _qr) {
+    async beforeUpdateOperation(dto, user, _qr) {
         for (const d of Array.isArray(dto) ? dto : [
             dto
         ]){
             const existing = await this.findOrFail(d.id);
-            const settings = toFlowSettings({
-                ...workingCopy(existing),
+            const merged = toFlowSettings({
+                ...existing,
                 ...stripUndefined(d)
             });
-            await this.assertSaveable(settings, user, existing.id);
-            if (!isPublished(existing)) await this.assertCallersKept(existing, settings, {
-                isActive: d.isActive ?? existing.isActive,
-                version: existing.version
-            });
-            if (d.nodes) d.nodes = (0,flow_api_key/* .sealApiKeys */.ue)(d.nodes);
-        }
-    }
-    /** A published flow keeps running as published: the edits go to its draft (none when they match what is live). */ async convertSingleDtoToEntity(dto, user) {
-        const id = dto.id;
-        if (!id) return super.convertSingleDtoToEntity(dto, user);
-        const existing = await this.findOrFail(id);
-        if (!isPublished(existing)) return super.convertSingleDtoToEntity(dto, user);
-        const draft = snapshotOf({
-            ...workingCopy(existing),
-            ...stripUndefined(dto)
-        });
-        existing.draft = sameSnapshot(draft, snapshotOf(existing)) ? null : draft;
-        return existing;
-    }
-    /**
-   * Makes the draft (or, before the first publish, the flow as saved) what callers run, as the next
-   * version. It is checked like a save, plus what only going live can break: other flows calling
-   * this one by a URL name or path it no longer has.
-   */ async publish(id, note, user) {
-        const existing = await this.findOrFail(id);
-        const published = isPublished(existing);
-        if (published && !existing.draft) throw new common_.BadRequestException({
-            message: 'There are no changes to publish.',
-            messageKey: message_keys/* .FLOW_MESSAGES.NOTHING_TO_PUBLISH */.wu.NOTHING_TO_PUBLISH
-        });
-        const next = workingCopy(existing);
-        const settings = toFlowSettings(next);
-        await this.assertSaveable(settings, user, existing.id);
-        await this.assertCallersKept(existing, settings, {
-            isActive: next.isActive ?? existing.isActive,
-            version: existing.version + 1
-        });
-        const qr = await this.provider.getQueryRunner();
-        try {
-            await qr.connect();
-            await qr.startTransaction();
-            const versions = qr.manager.getRepository(flow_version_entity/* .FlowVersion */.p);
-            // A version that went live before versions were kept is recorded now, so it can still be restored.
-            if (published && !await versions.exists({
-                where: {
-                    flowId: existing.id,
-                    version: existing.version
-                }
-            })) {
-                await versions.save(versions.create({
-                    flowId: existing.id,
-                    version: existing.version,
-                    definition: snapshotOf(existing),
-                    note: null,
-                    publishedAt: null,
-                    publishedById: null
-                }));
-            }
-            Object.assign(existing, next, {
-                draft: null,
-                version: existing.version + 1,
-                updatedById: user?.id ?? null
-            });
-            await qr.manager.getRepository(flow_definition_entity/* .FlowDefinition */.G).save(existing);
-            await versions.save(versions.create({
-                flowId: existing.id,
-                version: existing.version,
-                definition: next,
-                note: note?.trim() || null,
-                publishedAt: new Date(),
-                publishedById: user?.id ?? null
-            }));
-            await qr.commitTransaction();
-        } catch (error) {
-            await qr.rollbackTransaction().catch(()=>undefined);
-            throw error;
-        } finally{
-            await qr.release().catch(()=>undefined);
+            await this.assertSaveable(merged, user, existing.id);
+            if (merged.slug !== existing.slug) await this.assertNotCalled(existing.slug, [
+                existing.id
+            ]);
+            else await this.assertEndpointsNotCalled(existing, merged);
+            d.version = existing.version + 1;
         }
-        await this.clearCaches(existing);
-        await this.provisionPermissions([
-            existing
-        ]);
-        return existing;
-    }
-    /** Newest first, without the definitions (`getVersion` returns one in full). */ async listVersions(flowId) {
-        await this.findOrFail(flowId);
-        return (await this.provider.getRepository(flow_version_entity/* .FlowVersion */.p)).find({
-            where: {
-                flowId
-            },
-            order: {
-                version: 'DESC'
-            },
-            select: {
-                id: true,
-                flowId: true,
-                version: true,
-                note: true,
-                publishedAt: true,
-                publishedById: true
-            }
-        });
-    }
-    async getVersion(flowId, version) {
-        const row = await (await this.provider.getRepository(flow_version_entity/* .FlowVersion */.p)).findOne({
-            where: {
-                flowId,
-                version
-            }
-        });
-        if (!row) throw new common_.NotFoundException({
-            message: `Version ${version} of this flow was not found.`,
-            messageKey: message_keys/* .FLOW_MESSAGES.VERSION_NOT_FOUND */.wu.VERSION_NOT_FOUND,
-            messageVariables: {
-                version
-            }
-        });
-        return row;
-    }
-    /**
-   * Puts an old version back into the draft; callers keep the published flow until it is published
-   * again. Not checked like a save (the entities it names may have changed since), but the author
-   * still needs the permissions its run-as and code steps call for.
-   */ async restoreVersion(flowId, version, user) {
-        const flow = await this.findOrFail(flowId);
-        const snapshot = snapshotOf((await this.getVersion(flowId, version)).definition);
-        await this.assertMayAuthor(toFlowSettings(snapshot), user);
-        flow.draft = sameSnapshot(snapshot, snapshotOf(flow)) ? null : snapshot;
-        return this.saveDraft(flow, user);
-    }
-    async discardDraft(flowId, user) {
-        const flow = await this.findOrFail(flowId);
-        if (!flow.draft) throw new common_.BadRequestException({
-            message: 'This flow has no unpublished changes.',
-            messageKey: message_keys/* .FLOW_MESSAGES.NO_DRAFT */.wu.NO_DRAFT
-        });
-        flow.draft = null;
-        return this.saveDraft(flow, user);
-    }
-    async saveDraft(flow, user) {
-        await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).update(flow.id, {
-            draft: flow.draft,
-            updatedById: user?.id ?? null
-        });
-        await this.clearCaches(flow);
-        return flow;
-    }
-    async clearCaches(flow) {
-        if (!this.isCacheable) return;
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                flow
-            ])
-        ]);
     }
     async beforeDeleteOperation(dto, user, _qr) {
         const ids = Array.isArray(dto.id) ? dto.id : [
             dto.id
         ];
-        const flows = await (await this.provider.getRepository(flow_definition_entity/* .FlowDefinition */.G)).find({
+        const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G)).find({
             where: {
-                id: (0,external_typeorm_.In)(ids)
+                id: (0,typeorm__rspack_import_4.In)(ids)
             },
             withDeleted: true
         });
@@ -5126,50 +4312,39 @@ class FlowDefinitionService extends classes_.ApiService {
         if (dto.type === 'restore') return;
         for (const flow of flows)await this.assertNotCalled(flow.slug, ids);
     }
-    /** The execute permissions a published flow's URLs ask for (the flow's own and any a Request step sets), registered so they can be granted. */ async provisionPermissions(flows) {
+    async afterInsertOperation(entities) {
+        await this.provisionPermissions(entities);
+    }
+    async afterUpdateOperation(entities) {
+        await this.provisionPermissions(entities);
+    }
+    async provisionPermissions(flows) {
+        const needing = flows.filter((f)=>f.authMode === 'permission');
+        if (!needing.length) return;
         if (!this.actionRegistry) return;
-        const actions = new Map();
-        for (const flow of flows){
-            for (const endpoint of (0,flow_types/* .flowEndpoints */.Xr)(flow)){
-                if (endpoint.authMode !== 'permission') continue;
-                const code = endpoint.permissionCode || defaultFlowPermissionCode(flow.slug);
-                if (!actions.has(code)) actions.set(code, endpoint.path ? `Run ${flow.name} (${endpoint.path})` : `Run ${flow.name}`);
-            }
-        }
-        if (actions.size) await this.actionRegistry.registerActions([
-            ...actions
-        ].map(([code, name])=>({
-                code,
-                name
+        await this.actionRegistry.registerActions(needing.map((f)=>({
+                code: f.permissionCode || defaultFlowPermissionCode(f.slug),
+                name: `Run ${f.name}`
             })));
     }
 }
 FlowDefinitionService = _ts_decorate([
-    (0,common_.Injectable)({
-        scope: common_.Scope.REQUEST
+    (0,_nestjs_common__rspack_import_3.Injectable)({
+        scope: _nestjs_common__rspack_import_3.Scope.REQUEST
     }),
-    _ts_param(0, (0,common_.Inject)('CACHE_INSTANCE')),
-    _ts_param(1, (0,common_.Inject)(modules_.UtilsService)),
-    _ts_param(2, (0,common_.Inject)(entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D)),
-    _ts_param(3, (0,common_.Inject)(modules_.SharedPermissionCacheService)),
-    _ts_param(4, (0,common_.Optional)()),
-    _ts_param(4, (0,common_.Inject)(nestjs_shared_.PERMISSION_ACTION_REGISTRY)),
-    _ts_param(5, (0,common_.Optional)()),
-    _ts_param(5, (0,common_.Inject)(interfaces_.NOTIFICATION_ADAPTER)),
-    _ts_param(6, (0,common_.Optional)()),
-    _ts_param(6, (0,common_.Inject)(interfaces_.EMAIL_ADAPTER)),
-    _ts_param(7, (0,common_.Optional)()),
-    _ts_param(7, (0,common_.Inject)(interfaces_.COMPANY_ACCESS_RESOLVER)),
+    _ts_param(0, (0,_nestjs_common__rspack_import_3.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared_modules__rspack_import_2.UtilsService)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_3.Inject)(_entity_builder_datasource_provider_js__rspack_import_9/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared_modules__rspack_import_2.SharedPermissionCacheService)),
+    _ts_param(4, (0,_nestjs_common__rspack_import_3.Optional)()),
+    _ts_param(4, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared__rspack_import_0.PERMISSION_ACTION_REGISTRY)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof classes_.HybridCache === "undefined" ? Object : classes_.HybridCache,
-        typeof modules_.UtilsService === "undefined" ? Object : modules_.UtilsService,
-        typeof entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D,
-        typeof modules_.SharedPermissionCacheService === "undefined" ? Object : modules_.SharedPermissionCacheService,
-        typeof IPermissionActionRegistry === "undefined" ? Object : IPermissionActionRegistry,
-        typeof INotificationAdapter === "undefined" ? Object : INotificationAdapter,
-        typeof IEmailAdapter === "undefined" ? Object : IEmailAdapter,
-        typeof ICompanyAccessResolver === "undefined" ? Object : ICompanyAccessResolver
+        typeof _flusys_nestjs_shared_classes__rspack_import_1.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_1.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_2.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_2.UtilsService,
+        typeof _entity_builder_datasource_provider_js__rspack_import_9/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_9/* .EntityBuilderDataSourceProvider */.D,
+        typeof _flusys_nestjs_shared_modules__rspack_import_2.SharedPermissionCacheService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_2.SharedPermissionCacheService,
+        typeof IPermissionActionRegistry === "undefined" ? Object : IPermissionActionRegistry
     ])
 ], FlowDefinitionService);
 /** What the `call_flow` nodes of a flow run: a slug, and the path of the Request step they start at (null: the flow's own URL). */ function calledTargets(nodes) {
@@ -5181,13 +4356,6 @@ FlowDefinitionService = _ts_decorate([
         };
     });
 }
-/** What a Call flow step checks about a flow: it runs only once published and switched on. */ function callableOf(flow) {
-    return {
-        isActive: flow.isActive && isPublished(flow),
-        endpoints: (0,flow_types/* .flowEndpoints */.Xr)(flow),
-        calls: calledSlugs(flow.nodes)
-    };
-}
 /** Slugs the `call_flow` nodes of a flow run. */ function calledSlugs(nodes) {
     return calledTargets(nodes).map((target)=>target.slug);
 }
@@ -5195,6 +4363,14 @@ function stripUndefined(value) {
     return Object.fromEntries(Object.entries(value).filter(([, v])=>v !== undefined));
 }
 
+__webpack_require__.d(__webpack_exports__, {
+  RK: () => (toFlowSettings),
+  Tk: () => (FlowDefinitionService)
+}, {
+  Er: defaultFlowPermissionCode,
+  YW: flowNotFound
+});
+
 
 },
 7810(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -5252,7 +4428,6 @@ class FlowExecutionService {
             await repo.save(repo.create({
                 flowId: entry.flowId,
                 flowSlug: entry.flowSlug,
-                flowVersion: entry.flowVersion,
                 status: entry.result.status,
                 trigger: entry.trigger,
                 mode: entry.mode,
@@ -5317,7 +4492,6 @@ class FlowExecutionService {
                 id: true,
                 flowId: true,
                 flowSlug: true,
-                flowVersion: true,
                 status: true,
                 trigger: true,
                 mode: true,
@@ -5376,8 +4550,6 @@ __webpack_require__.d(__webpack_exports__, {
 var classes_ = __webpack_require__(6937);
 // EXTERNAL MODULE: external "@flusys/nestjs-shared/exceptions"
 var exceptions_ = __webpack_require__(2417);
-// EXTERNAL MODULE: external "@flusys/nestjs-shared/interfaces"
-var interfaces_ = __webpack_require__(5103);
 // EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
 var modules_ = __webpack_require__(1236);
 // EXTERNAL MODULE: external "@nestjs/common"
@@ -5617,14 +4789,14 @@ const BLOCKED_REQUEST_HEADERS = new Set([
     });
 }
 
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/index.ts + 1 modules
-var rule_engine = __webpack_require__(8429);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/index.ts + 2 modules
+var rule_engine = __webpack_require__(5920);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-builder-config.service.ts
 var entity_builder_config_service = __webpack_require__(4281);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-builder-datasource.provider.ts
 var entity_builder_datasource_provider = __webpack_require__(424);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts + 1 modules
-var flow_definition_service = __webpack_require__(4921);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts
+var flow_definition_service = __webpack_require__(5229);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/generic-entity.service.ts
 var generic_entity_service = __webpack_require__(3998);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/generic-entity-service.factory.ts
@@ -5672,7 +4844,6 @@ function _ts_param(paramIndex, decorator) {
 
 
 
-
 
 
 const publishFlowEvent = (eventName, payload, user)=>(0,classes_.publishDomainEvent)({
@@ -5682,31 +4853,27 @@ const publishFlowEvent = (eventName, payload, user)=>(0,classes_.publishDomainEv
         metadata: payload,
         user
     });
-/** The run's time budget, whatever a Request step asks for. */ const flowTimeout = (timeoutMs)=>typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) ? Math.min(Math.max(timeoutMs, flow_types/* .FLOW_LIMITS.MIN_TIMEOUT_MS */.Or.MIN_TIMEOUT_MS), flow_types/* .FLOW_LIMITS.MAX_TIMEOUT_MS */.Or.MAX_TIMEOUT_MS) : flow_types/* .FLOW_LIMITS.DEFAULT_TIMEOUT_MS */.Or.DEFAULT_TIMEOUT_MS;
+/** The run's time budget, whatever a definition asks for. */ const flowTimeout = (timeoutMs)=>typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) ? Math.min(Math.max(timeoutMs, flow_types/* .FLOW_LIMITS.MIN_TIMEOUT_MS */.Or.MIN_TIMEOUT_MS), flow_types/* .FLOW_LIMITS.MAX_TIMEOUT_MS */.Or.MAX_TIMEOUT_MS) : flow_types/* .FLOW_LIMITS.DEFAULT_TIMEOUT_MS */.Or.DEFAULT_TIMEOUT_MS;
 class FlowExecutorService {
     provider;
     ruleEngine;
     moduleRef;
     permissionCache;
     config;
-    companyAccess;
-    notifications;
-    email;
     logger = new common_.Logger(FlowExecutorService.name);
-    constructor(provider, ruleEngine, moduleRef, permissionCache, config, companyAccess, notifications, email){
+    constructor(provider, ruleEngine, moduleRef, permissionCache, config){
         this.provider = provider;
         this.ruleEngine = ruleEngine;
         this.moduleRef = moduleRef;
         this.permissionCache = permissionCache;
         this.config = config;
-        this.companyAccess = companyAccess;
-        this.notifications = notifications;
-        this.email = email;
     }
-    async run(flow, options) {
+    async run(definition, options) {
         const startedAt = Date.now();
-        const start = (0,flow_types/* .startEndpoint */.IE)(flow, options.startAt);
-        const runAs = start?.runAs ?? 'caller';
+        const flow = {
+            ...definition,
+            timeoutMs: flowTimeout(definition.timeoutMs)
+        };
         const state = {
             startAt: options.startAt,
             input: options.input,
@@ -5714,16 +4881,14 @@ class FlowExecutorService {
             context: {},
             request: options.request,
             user: options.user,
-            authorization: options.authorization,
             permissions: this.ruleEngine.createPermissionResolver(options.user),
             mode: options.mode,
-            runAs,
-            systemAuthorized: runAs === 'system' && options.systemAuthorized === true,
+            runAs: flow.runAs,
+            systemAuthorized: flow.runAs === 'system' && options.systemAuthorized === true,
             steps: 0,
             httpCalls: 0,
-            messages: 0,
             writes: 0,
-            deadline: startedAt + flowTimeout(start?.timeoutMs),
+            deadline: startedAt + flow.timeoutMs,
             callStack: [
                 flow.slug
             ],
@@ -5731,15 +4896,15 @@ class FlowExecutorService {
             trace: []
         };
         try {
-            if (!flow_types/* .FLOW_RUN_AS.includes */.gl.includes(runAs)) {
+            if (!flow_types/* .FLOW_RUN_AS.includes */.gl.includes(flow.runAs)) {
                 throw new flow_errors/* .FlowHttpError */.hk(403, 'This flow is not allowed to run.', undefined, {
                     messageKey: message_keys/* .FLOW_ERROR_MESSAGES.RUN_AS_NOT_ALLOWED */.zr.RUN_AS_NOT_ALLOWED,
                     messageVariables: {
-                        runAs: String(runAs)
+                        runAs: String(flow.runAs)
                     }
                 });
             }
-            await this.execute(flow, start?.isTransactional === true, state, this.createEnv());
+            await this.execute(flow, state, this.createEnv());
             return {
                 ...(0,flow_engine/* .successResult */.JK)(state, startedAt),
                 ...state.savedUpTo ? {
@@ -5769,10 +4934,10 @@ class FlowExecutorService {
         }
     }
     /**
-   * Walks `flow`. A flow called from inside a transaction joins it; otherwise a run whose Request step
-   * is transactional (or any test run) gets its own, and its held-back events are published after the commit.
-   */ async execute(flow, transactional, state, env) {
-        if (state.qr || !(transactional || state.mode === 'dry_run')) {
+   * Walks `flow`. A flow called from inside a transaction joins it; otherwise a transactional
+   * flow (or any test run) gets its own, and its held-back events are published after the commit.
+   */ async execute(flow, state, env) {
+        if (state.qr || !(flow.isTransactional || state.mode === 'dry_run')) {
             await new flow_engine/* .FlowEngine */.$I(flow, env).walk(state);
             return;
         }
@@ -5851,6 +5016,7 @@ class FlowExecutorService {
             max: flow_types/* .FLOW_LIMITS.MAX_CALL_DEPTH */.Or.MAX_CALL_DEPTH
         });
         const flow = await this.findCallable(slug, parent.qr);
+        await this.assertMayCall(flow, parent, env);
         const settings = (0,flow_definition_service/* .toFlowSettings */.RK)(flow);
         const start = (0,flow_types/* .findEndpoint */.vS)(settings, endpoint);
         if (!start) {
@@ -5859,7 +5025,6 @@ class FlowExecutorService {
                 endpoint: endpoint ?? ''
             }, `Flow '${slug}' has no URL '${endpoint ?? ''}'.`);
         }
-        await this.assertMayCall(flow, start, parent, env);
         const checked = (0,flow_input_validator/* .validateFlowInput */.v)(start.inputSchema, input, start.bodyType);
         if (checked.errors.length) {
             throw new flow_errors/* .FlowHttpError */.hk(400, 'Validation failed', checked.errors, {
@@ -5876,17 +5041,15 @@ class FlowExecutorService {
             context: {},
             request: parent.request,
             user: parent.user,
-            authorization: parent.authorization,
             permissions: parent.permissions,
             mode: parent.mode,
-            runAs: start.authMode === 'internal' ? parent.runAs : start.runAs,
-            // A function inherits the caller's grant; any other called flow is a saved flow whose Request steps' run-as was checked when it was saved.
-            systemAuthorized: start.authMode === 'internal' ? parent.systemAuthorized === true : start.runAs === 'system',
+            runAs: flow.authMode === 'internal' ? parent.runAs : settings.runAs,
+            // A function inherits the caller's grant; any other called flow is a saved flow whose own run-as was checked when it was saved.
+            systemAuthorized: flow.authMode === 'internal' ? parent.systemAuthorized === true : settings.runAs === 'system',
             steps: parent.steps,
             httpCalls: parent.httpCalls,
-            messages: parent.messages,
             writes: parent.writes,
-            deadline: Math.min(parent.deadline, Date.now() + flowTimeout(start.timeoutMs)),
+            deadline: Math.min(parent.deadline, Date.now() + flowTimeout(settings.timeoutMs)),
             qr: parent.qr,
             callStack: [
                 ...parent.callStack,
@@ -5901,14 +5064,13 @@ class FlowExecutorService {
             if (child.pendingEvents === parent.pendingEvents) parent.pendingEvents.length = queued;
         };
         try {
-            await this.execute(settings, start.isTransactional, child, env);
+            await this.execute(settings, child, env);
         } catch (error) {
             dropQueued();
             throw calledFlowFailure(flow, error);
         } finally{
             parent.steps = child.steps;
             parent.httpCalls = child.httpCalls;
-            parent.messages = child.messages;
             parent.writes = child.writes;
         }
         if (child.response) {
@@ -5927,8 +5089,7 @@ class FlowExecutorService {
             where: {
                 slug,
                 isActive: true,
-                deletedAt: (0,external_typeorm_.IsNull)(),
-                version: (0,external_typeorm_.MoreThan)(0)
+                deletedAt: (0,external_typeorm_.IsNull)()
             }
         });
         if (!flow) throw new flow_errors/* .FlowKeyedError */.Hp(message_keys/* .FLOW_ERROR_MESSAGES.CALLED_FLOW_NOT_FOUND */.zr.CALLED_FLOW_NOT_FOUND, {
@@ -5938,22 +5099,20 @@ class FlowExecutorService {
     }
     /**
    * Any flow may call a function, and a flow running as the system may call any flow. One running
-   * as the caller may call only the URLs that caller could call directly: public and signed-in ones,
-   * and permission ones when the caller holds the permission - never an API-key one.
-   */ async assertMayCall(flow, endpoint, parent, env) {
-        const mode = endpoint.authMode;
-        if (parent.runAs === 'system' && parent.systemAuthorized === true || mode === 'public' || mode === 'internal') return;
-        if (mode === 'api_key' || !parent.user) {
+   * as the caller may call only what that caller could call directly: public and signed-in flows,
+   * and permission flows when the caller holds the permission - never an API-key flow.
+   */ async assertMayCall(flow, parent, env) {
+        if (parent.runAs === 'system' && parent.systemAuthorized === true || flow.authMode === 'public' || flow.authMode === 'internal') return;
+        if (flow.authMode === 'api_key' || !parent.user) {
             throw new flow_errors/* .FlowKeyedError */.Hp(message_keys/* .FLOW_ERROR_MESSAGES.CALLED_FLOW_NOT_ALLOWED */.zr.CALLED_FLOW_NOT_ALLOWED, {
                 flow: flow.slug,
-                authMode: mode
-            }, `Flow '${flow.slug}' (${mode}) cannot be called by this caller.`);
+                authMode: flow.authMode
+            }, `Flow '${flow.slug}' (${flow.authMode}) cannot be called by this caller.`);
         }
-        if (mode === 'permission') await env.assertPermission(endpoint.permissionCode || (0,flow_definition_service/* .defaultFlowPermissionCode */.Er)(flow.slug), parent.user);
+        if (flow.authMode === 'permission') await env.assertPermission(flow.permissionCode || (0,flow_definition_service/* .defaultFlowPermissionCode */.Er)(flow.slug), parent.user);
     }
     createEnv() {
         const entityServices = new Map();
-        /** One lookup per user for the whole run, however many steps ask. */ const access = new Map();
         let permissions;
         const env = {
             ruleEngine: this.ruleEngine,
@@ -5976,18 +5135,6 @@ class FlowExecutorService {
             atomic: (state, work)=>this.atomic(state, work),
             commit: (state)=>this.commitProgress(state),
             http: flowHttpRequest,
-            notifications: this.notifications,
-            email: this.email,
-            ...this.companyAccess ? {
-                companyMembers: (companyId, branchIds)=>this.companyAccess.getCompanyMembers(companyId, branchIds)
-            } : {},
-            companyAccess: (userId)=>{
-                if (!access.has(userId)) access.set(userId, this.companyAccess ? this.companyAccess.getUserAccess(userId) : Promise.resolve({
-                    companies: [],
-                    branches: []
-                }));
-                return access.get(userId);
-            },
             publish: (eventName, payload, user)=>publishFlowEvent(eventName, payload, user),
             assertPermission: async (code, user)=>{
                 if (!user) throw new common_.UnauthorizedException({
@@ -6008,13 +5155,9 @@ class FlowExecutorService {
         };
         return env;
     }
-    /** After commit, so listeners see committed data and messages go out only for what was saved. A failing publish or send never turns a completed run into an error. */ async publishPendingEvents(events, user) {
+    /** After commit, so listeners see committed data. A failing publish never turns a completed run into an error. */ async publishPendingEvents(events, user) {
         for (const event of events){
             try {
-                if ('delivery' in event) {
-                    await event.send();
-                    continue;
-                }
                 if ('eventName' in event) {
                     await publishFlowEvent(event.eventName, event.payload, user);
                     continue;
@@ -6033,10 +5176,6 @@ class FlowExecutorService {
                     user
                 });
             } catch (error) {
-                if ('delivery' in event) {
-                    this.logger.error(`Could not send the message of "${event.delivery}" after the commit: ${error.message}`);
-                    continue;
-                }
                 const name = 'eventName' in event ? event.eventName : `${event.entityCode}.${event.action}`;
                 this.logger.error(`Could not publish ${name}: ${error.message}`);
             }
@@ -6050,22 +5189,13 @@ FlowExecutorService = _ts_decorate([
     _ts_param(2, (0,common_.Inject)(core_.ModuleRef)),
     _ts_param(3, (0,common_.Inject)(modules_.SharedPermissionCacheService)),
     _ts_param(4, (0,common_.Inject)(entity_builder_config_service/* .EntityBuilderConfigService */.E)),
-    _ts_param(5, (0,common_.Optional)()),
-    _ts_param(5, (0,common_.Inject)(interfaces_.COMPANY_ACCESS_RESOLVER)),
-    _ts_param(6, (0,common_.Optional)()),
-    _ts_param(6, (0,common_.Inject)(interfaces_.NOTIFICATION_ADAPTER)),
-    _ts_param(7, (0,common_.Optional)()),
-    _ts_param(7, (0,common_.Inject)(interfaces_.EMAIL_ADAPTER)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : entity_builder_datasource_provider/* .EntityBuilderDataSourceProvider */.D,
         typeof rule_engine/* .RuleEngineService */.iI === "undefined" ? Object : rule_engine/* .RuleEngineService */.iI,
         typeof core_.ModuleRef === "undefined" ? Object : core_.ModuleRef,
         typeof modules_.SharedPermissionCacheService === "undefined" ? Object : modules_.SharedPermissionCacheService,
-        typeof entity_builder_config_service/* .EntityBuilderConfigService */.E === "undefined" ? Object : entity_builder_config_service/* .EntityBuilderConfigService */.E,
-        typeof ICompanyAccessResolver === "undefined" ? Object : ICompanyAccessResolver,
-        typeof INotificationAdapter === "undefined" ? Object : INotificationAdapter,
-        typeof IEmailAdapter === "undefined" ? Object : IEmailAdapter
+        typeof entity_builder_config_service/* .EntityBuilderConfigService */.E === "undefined" ? Object : entity_builder_config_service/* .EntityBuilderConfigService */.E
     ])
 ], FlowExecutorService);
 /** A rejection or a limit inside the called flow is passed on as it is; anything else fails the calling node with the reason. */ function calledFlowFailure(flow, error) {
@@ -6106,7 +5236,7 @@ FlowExecutorService = _ts_decorate([
 /* import */ var _flow_engine_flow_input_validator_js__rspack_import_3 = __webpack_require__(6390);
 /* import */ var _flow_engine_flow_types_js__rspack_import_4 = __webpack_require__(6256);
 /* import */ var _entity_builder_datasource_provider_js__rspack_import_5 = __webpack_require__(424);
-/* import */ var _flow_definition_service_js__rspack_import_6 = __webpack_require__(4921);
+/* import */ var _flow_definition_service_js__rspack_import_6 = __webpack_require__(5229);
 /* import */ var _flow_execution_service_js__rspack_import_7 = __webpack_require__(7810);
 /* import */ var _flow_executor_service_js__rspack_import_8 = __webpack_require__(4698);
 function _ts_decorate(decorators, target, key, desc) {
@@ -6178,11 +5308,6 @@ const MAX_QUERY_VALUE_LENGTH = 2000;
         receivedAt: new Date().toISOString()
     };
 }
-/** The caller's own `Authorization` header, kept for Request steps that forward it: only for a signed-in (verified) caller. */ function callerAuthorization(caller, user) {
-    if (!user) return undefined;
-    const value = Object.entries(caller.headers).find(([key])=>key.toLowerCase() === 'authorization')?.[1];
-    return typeof value === 'string' && value ? value : undefined;
-}
 /** A test run's request: the designer's own, with the headers / query / IP the author chose to simulate on top. */ function simulatedCaller(caller, simulated) {
     if (!simulated) return caller;
     const headers = {
@@ -6222,13 +5347,13 @@ class FlowRuntimeService {
         this.executions = executions;
         this.definitions = definitions;
     }
-    /** A flow never published is not live yet: it looks the same as an unknown one. */ async findActive(slug) {
+    /** A function flow has no endpoint: it looks the same as an unknown one. */ async findActive(slug) {
         return (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_2/* .FlowDefinition */.G)).findOne({
             where: {
                 slug,
                 isActive: true,
                 deletedAt: (0,typeorm__rspack_import_1.IsNull)(),
-                version: (0,typeorm__rspack_import_1.MoreThan)(0)
+                authMode: (0,typeorm__rspack_import_1.Not)('internal')
             }
         });
     }
@@ -6240,14 +5365,13 @@ class FlowRuntimeService {
             await this.logWebhook(flow, body, result, startedAt, user, caller);
             return result;
         }
-        // A saved flow: saving a Request step as `runAs: system` needed the system permission.
+        // A saved flow: saving it as `runAs: system` needed the system permission.
         const result = await this.executor.run((0,_flow_definition_service_js__rspack_import_6/* .toFlowSettings */.RK)(flow), {
             mode: 'live',
             user,
             input: checked.values,
             startAt: endpoint.nodeId,
             request: requestInfo(caller),
-            authorization: callerAuthorization(caller, user),
             exposeDetails: false,
             systemAuthorized: true
         });
@@ -6256,6 +5380,7 @@ class FlowRuntimeService {
     }
     /** The designer's "Test run": a saved flow or an unsaved draft. */ async testRun(dto, user, caller) {
         let settings;
+        let permissionCode;
         let flow = null;
         if (dto.flowId) {
             flow = await this.definitions.findOrFail(dto.flowId);
@@ -6263,8 +5388,10 @@ class FlowRuntimeService {
         if (dto.definition) {
             // The designer's current draft, even for a saved flow: `flow` above is kept only to attribute the run.
             settings = (0,_flow_definition_service_js__rspack_import_6/* .toFlowSettings */.RK)(dto.definition);
+            permissionCode = dto.definition.permissionCode;
         } else if (flow) {
             settings = (0,_flow_definition_service_js__rspack_import_6/* .toFlowSettings */.RK)(flow);
+            permissionCode = flow.permissionCode;
         } else {
             throw new _nestjs_common__rspack_import_0.BadRequestException({
                 message: 'Send a flowId or a definition to test.',
@@ -6272,22 +5399,15 @@ class FlowRuntimeService {
             });
         }
         const mode = dto.mode ?? 'dry_run';
-        const endpoint = (0,_flow_engine_flow_types_js__rspack_import_4/* .findEndpoint */.vS)(settings, dto.endpoint);
         // Checked before anything runs; passing it is what lets a `runAs: system` test touch entities.
-        await this.definitions.assertMayTest(settings, endpoint, user, {
+        await this.definitions.assertMayTest({
+            ...settings,
+            permissionCode
+        }, user, {
             mode,
             draft: !!dto.definition,
             saved: !!flow
         });
-        if (!endpoint) {
-            throw new _nestjs_common__rspack_import_0.BadRequestException({
-                message: `This flow has no URL '${dto.endpoint ?? ''}'.`,
-                messageKey: _config_message_keys_js__rspack_import_9/* .FLOW_MESSAGES.ENDPOINT_NOT_FOUND */.wu.ENDPOINT_NOT_FOUND,
-                messageVariables: {
-                    endpoint: dto.endpoint ?? ''
-                }
-            });
-        }
         const validation = await this.definitions.validate(settings);
         if (validation.errors.length) {
             throw new _nestjs_common__rspack_import_0.BadRequestException({
@@ -6299,6 +5419,16 @@ class FlowRuntimeService {
                     }))
             });
         }
+        const endpoint = (0,_flow_engine_flow_types_js__rspack_import_4/* .findEndpoint */.vS)(settings, dto.endpoint);
+        if (!endpoint) {
+            throw new _nestjs_common__rspack_import_0.BadRequestException({
+                message: `This flow has no URL '${dto.endpoint ?? ''}'.`,
+                messageKey: _config_message_keys_js__rspack_import_9/* .FLOW_MESSAGES.ENDPOINT_NOT_FOUND */.wu.ENDPOINT_NOT_FOUND,
+                messageVariables: {
+                    endpoint: dto.endpoint ?? ''
+                }
+            });
+        }
         const startedAt = new Date();
         const simulated = simulatedCaller(caller, dto.request);
         const body = dto.input ?? (endpoint.bodyType === 'list' ? [] : {});
@@ -6309,14 +5439,12 @@ class FlowRuntimeService {
             input: checked.values,
             startAt: endpoint.nodeId,
             request: requestInfo(simulated),
-            authorization: callerAuthorization(caller, user),
             exposeDetails: true,
             systemAuthorized: true
         });
         await this.executions.record({
             flowId: flow?.id ?? null,
             flowSlug: settings.slug,
-            flowVersion: dto.definition ? null : flow?.version ?? null,
             trigger: 'test',
             mode,
             input: body,
@@ -6335,7 +5463,6 @@ class FlowRuntimeService {
         await this.executions.record({
             flowId: flow.id,
             flowSlug: flow.slug,
-            flowVersion: flow.version,
             trigger: 'webhook',
             mode: 'live',
             input,
@@ -6738,7 +5865,6 @@ const FILTER_COMPARISON_SQL = {
     /** Soft-deletes the record, or deletes it for good when the entity has soft delete turned off. */ async delete(id, user, options = {}) {
         this.ensureActive();
         const repository = await this.ensureRepository();
-        const soft = this.definition.isSoftDeleteEnabled;
         await this.withTransaction(options, async (queryRunner)=>{
             const existing = await queryRunner.manager.findOne(repository.target, {
                 where: {
@@ -6746,6 +5872,7 @@ const FILTER_COMPARISON_SQL = {
                 }
             });
             if (!existing) throw this.notFound(id);
+            const soft = this.definition.isSoftDeleteEnabled;
             if (soft) {
                 await queryRunner.manager.softDelete(repository.target, [
                     id
@@ -6771,7 +5898,6 @@ const FILTER_COMPARISON_SQL = {
                 ]
             };
         }, user);
-        return soft ? 'deleted' : 'purged';
     }
     async findById(id, options = {}) {
         const repository = await this.repositoryFor(options.queryRunner);