@flusys/nestjs-entity-builder 9.1.2 → 9.2.1

package/fesm/677.js

@@ -9,11 +9,13 @@ 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__flusys_nestjs_shared_exceptions_3edf22e9 from "@flusys/nestjs-shared/exceptions";
 import * as __rspack_external_node_dns_c6249ebb from "node:dns";
+import * as __rspack_external_typeorm_persistence_Subject_js_50dfc7e4 from "typeorm/persistence/Subject.js";
+import * as __rspack_external_typeorm_persistence_SubjectExecutor_js_7cea48f1 from "typeorm/persistence/SubjectExecutor.js";
 export const __rspack_esm_id = 677;
 export const __rspack_esm_ids = [677];
 export const __webpack_modules__ = {
 982(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/** Every entity the entity builder module publishes under */ const ENTITY_BUILDER_EVENT_ENTITIES = {
+/** The entity names the module publishes events under; also reserved as entity codes. */ const ENTITY_BUILDER_EVENT_ENTITIES = {
     ENTITY_DEFINITION: 'entity_definition',
     FIELD_DEFINITION: 'field_definition',
     SCHEMA_CHANGE_LOG: 'schema_change_log',
@@ -84,7 +86,7 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 },
-8333(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+3931(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -114,7 +116,7 @@ var flow_types = __webpack_require__(6256);
 
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/redact.ts
 var redact = __webpack_require__(2678);
-;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-code-sandbox.ts
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-code-runner.ts
 
 
 
@@ -123,7 +125,7 @@ var redact = __webpack_require__(2678);
 
 
 
-const PRELUDE = `(function (input, hostLog, sensitive, maxChars) {
+const PRELUDE = `(function (input, hostLog, sensitive, maxChars, hostRequire, hostFetch, hostTimers) {
   'use strict';
   const freeze = (o) => {
     if (o && typeof o === 'object' && !Object.isFrozen(o)) {
@@ -148,136 +150,191 @@ const PRELUDE = `(function (input, hostLog, sensitive, maxChars) {
   const held = (code) => typeof code === 'string' && granted.some((p) => p === code || p === '*' || (p.endsWith('.*') && code.startsWith(p.slice(0, -1))));
   const codes = (args) => args.flat().filter((c) => typeof c === 'string' && c);
   const constant = (name, value) => Object.defineProperty(globalThis, name, { value, writable: false, configurable: false });
+  const textOf = (body) => (typeof body === 'string' ? body : JSON.stringify(body));
+  const timer = (repeat) => (fn, ms, ...args) => (typeof fn === 'function' ? hostTimers.set(() => fn(...args), Number(ms) || 0, repeat) : 0);
+  const clear = (id) => { hostTimers.clear(id); };
   Object.defineProperty(globalThis, 'ctx', { value: ctx, writable: false, configurable: false, enumerable: true });
-  constant('console', freeze({ log, info: log, warn: log, error: log }));
+  constant('console', freeze({ log, info: log, warn: log, error: log, debug: log }));
   constant('hasPermission', (code) => held(code));
   constant('hasAnyPermission', (...list) => codes(list).some(held));
   constant('hasAllPermissions', (...list) => { const c = codes(list); return c.length > 0 && c.every(held); });
+  constant('require', (name) => hostRequire(String(name)));
+  constant('fetch', async (url, init) => {
+    const options = init && typeof init === 'object' ? init : {};
+    const headers = {};
+    for (const [k, v] of Object.entries(options.headers && typeof options.headers === 'object' ? options.headers : {})) headers[k] = String(v);
+    const body = options.body === undefined || options.body === null ? undefined : textOf(options.body);
+    const r = JSON.parse(await hostFetch(String(url), String(options.method || 'GET').toUpperCase(), JSON.stringify(headers), body));
+    return freeze({
+      status: r.status,
+      ok: r.ok,
+      headers: r.headers,
+      text: async () => textOf(r.body),
+      json: async () => (typeof r.body === 'string' ? JSON.parse(r.body) : r.body),
+    });
+  });
+  constant('setTimeout', timer(false));
+  constant('setInterval', timer(true));
+  constant('clearTimeout', clear);
+  constant('clearInterval', clear);
 })`;
-const SERIALIZE = `(function (v) { const s = JSON.stringify(v); return s === undefined ? 'null' : s; })`;
-/** Runs in a worker thread, so a busy QuickJS loop never blocks the server's event loop. */ const WORKER_SOURCE = `
+/** Runs in a worker thread, so a busy code step never blocks the server's event loop. */ const WORKER_SOURCE = `
 'use strict';
+const vm = require('node:vm');
 const { parentPort, workerData } = require('node:worker_threads');
 const { createRequire } = require('node:module');
-const { bases, prelude, serialize, sensitive, limits, keys } = workerData;
-let quickJs;
-
-function load() {
-  if (!quickJs) {
-    let lastError = new Error('quickjs-emscripten could not be resolved');
-    for (const base of bases) {
+const { bases, prelude, sensitive, limits, keys } = workerData;
+const requirers = bases.map((base) => createRequire(base));
+const packages = new Map();
+const fetches = new Map();
+let fetchCalls = 0;
+const TIMED_OUT = Symbol('timed out');
+const HOST_GLOBALS = { Buffer, URL, URLSearchParams, TextEncoder, TextDecoder, AbortController, AbortSignal, atob, btoa, structuredClone };
+
+// Code that drops a rejected promise must not take the worker down.
+process.on('unhandledRejection', () => {});
+
+function load(specifier) {
+  if (!packages.has(specifier)) {
+    let outcome = { error: new Error('The package "' + specifier + '" is not installed on the server.') };
+    for (const req of requirers) {
       try {
-        quickJs = createRequire(base)('quickjs-emscripten').getQuickJS();
+        outcome = { value: req(specifier) };
         break;
       } catch (error) {
-        lastError = error;
+        if (!error || error.code !== 'MODULE_NOT_FOUND') {
+          outcome = { error };
+          break;
+        }
       }
     }
-    if (!quickJs) throw lastError;
-    quickJs.catch(() => { quickJs = undefined; });
+    packages.set(specifier, outcome);
   }
-  return quickJs;
+  const outcome = packages.get(specifier);
+  if (outcome.error) throw outcome.error;
+  return outcome.value;
 }
 
-const failure = (key, vars, detail, logs) => ({ failure: { key, vars, detail, logs } });
+const failure = (key, vars, detail, logs, recycle) => ({ failure: { key, vars, detail, logs }, recycle });
 
-function toFailure(vm, errorHandle, job, deadline, logs) {
-  let name = '';
-  let message = '';
+function describe(error) {
   try {
-    const dumped = vm.dump(errorHandle);
-    if (dumped && typeof dumped === 'object') {
-      name = String(dumped.name ?? '');
-      message = String(dumped.message ?? '');
-    } else {
-      message = String(dumped);
+    if (error && typeof error === 'object') {
+      const name = typeof error.name === 'string' ? error.name : '';
+      const message = typeof error.message === 'string' ? error.message : String(error);
+      return (name ? name + ': ' + message : message).slice(0, limits.logLineChars);
     }
+    return String(error).slice(0, limits.logLineChars);
   } catch (e) {
-    message = 'unknown error';
+    return 'unknown error';
   }
-  if (/out of memory/i.test(message)) {
-    const mb = limits.memoryBytes / (1024 * 1024);
-    return failure(keys.outOfMemory, { node: job.node, mb }, 'The code used more than ' + mb + ' MB of memory.', logs);
-  }
-  if ((name === 'InternalError' && message === 'interrupted') || Date.now() > deadline) {
-    return failure(keys.timeout, { node: job.node, ms: job.timeoutMs }, 'The code ran longer than ' + job.timeoutMs + ' ms.', logs);
-  }
-  const detail = (name ? name + ': ' + message : message).slice(0, limits.logLineChars);
-  return failure(keys.threw, { node: job.node, detail }, detail, logs);
 }
 
-function run(module, job) {
+async function run(job) {
   const logs = [];
   const deadline = Date.now() + job.timeoutMs;
-  const runtime = module.newRuntime();
-  runtime.setMemoryLimit(limits.memoryBytes);
-  runtime.setMaxStackSize(limits.stackBytes);
-  runtime.setInterruptHandler(() => Date.now() > deadline);
-  const vm = runtime.newContext();
-  const handles = [];
-  const keep = (handle) => (handles.push(handle), handle);
-  const unwrap = (result) => {
-    if (result.error) {
-      keep(result.error);
-      throw toFailure(vm, result.error, job, deadline, logs);
-    }
-    return keep(result.value);
+  const remaining = () => Math.max(1, deadline - Date.now());
+  const timedOut = (recycle) => failure(keys.timeout, { node: job.node, ms: job.timeoutMs }, 'The code ran longer than ' + job.timeoutMs + ' ms.', logs, recycle);
+  const timers = new Map();
+  let nextTimer = 1;
+  let failAsync;
+  const asyncFailure = new Promise((resolve, reject) => { failAsync = reject; });
+  asyncFailure.catch(() => {});
+
+  const modules = job.modules;
+  // Loaded before the clock starts, so a package's first load never eats the code's time limit.
+  for (const specifier of Object.values(modules)) {
+    try { load(specifier); } catch (e) { /* reported when the code asks for it */ }
+  }
+  const hostRequire = (name) => {
+    if (!Object.hasOwn(modules, name)) {
+      const allowed = Object.keys(modules).join(', ') || 'none';
+      throw new Error('The package "' + name + '" is not allowed. Allowed: ' + allowed + '.');
+    }
+    return load(modules[name]);
   };
+  const hostFetch = (url, method, headers, body) =>
+    new Promise((resolve, reject) => {
+      const call = ++fetchCalls;
+      fetches.set(call, { resolve, reject });
+      parentPort.postMessage({ type: 'fetch', id: job.id, call, request: { url, method, headers: JSON.parse(headers), body } });
+    });
+  const hostTimers = {
+    set(fn, ms, repeat) {
+      const id = nextTimer++;
+      const tick = () => {
+        if (!repeat) timers.delete(id);
+        try { fn(); } catch (error) { failAsync(error); }
+      };
+      timers.set(id, repeat ? setInterval(tick, Math.max(0, ms)) : setTimeout(tick, Math.max(0, ms)));
+      return id;
+    },
+    clear(id) {
+      const handle = timers.get(id);
+      if (handle === undefined) return;
+      clearTimeout(handle);
+      timers.delete(id);
+    },
+  };
+  const hostLog = (line) => {
+    if (logs.length < limits.logLines) logs.push(String(line));
+  };
+
+  const context = vm.createContext({ ...HOST_GLOBALS }, { name: 'flow-code', codeGeneration: { strings: true, wasm: false } });
+  let watch;
   try {
-    const hostLog = keep(vm.newFunction('log', (line) => {
-      if (logs.length < limits.logLines) logs.push(vm.getString(line));
-    }));
-    const preludeFn = unwrap(vm.evalCode(prelude, 'flow-prelude.js'));
-    unwrap(vm.callFunction(preludeFn, vm.undefined, keep(vm.newString(job.input)), hostLog, keep(vm.newString(sensitive)), keep(vm.newNumber(limits.logLineChars))));
-
-    const userFn = unwrap(vm.evalCode('(function () {\\n\\'use strict\\';\\n' + job.code + '\\n})', 'flow-code.js'));
-    if (vm.typeof(userFn) !== 'function') return failure(keys.threw, { node: job.node, detail: 'The code is not a function body.' }, 'The code is not a function body.', logs);
-    const resultHandle = unwrap(vm.callFunction(userFn, vm.undefined));
-
-    const serializer = unwrap(vm.evalCode(serialize, 'flow-serialize.js'));
-    const serialized = vm.callFunction(serializer, vm.undefined, resultHandle);
-    if (serialized.error) {
-      keep(serialized.error);
-      if (Date.now() > deadline) return toFailure(vm, serialized.error, job, deadline, logs);
+    vm.runInContext(prelude, context, { filename: 'flow-prelude.js' })(job.input, hostLog, sensitive, limits.logLineChars, hostRequire, hostFetch, hostTimers);
+    const pending = vm.runInContext("(async function () {\\n'use strict';\\n" + job.code + '\\n})()', context, { filename: 'flow-code.js', timeout: job.timeoutMs });
+    const clock = new Promise((resolve, reject) => { watch = setTimeout(() => reject(TIMED_OUT), remaining()); });
+    const value = await Promise.race([pending, clock, asyncFailure]);
+    clearTimeout(watch);
+
+    const slot = '__flow_result_' + job.id;
+    Object.defineProperty(context, slot, { value, configurable: true });
+    let json;
+    try {
+      json = vm.runInContext('(function (v) { const s = JSON.stringify(v); return s === undefined ? "null" : s; })(globalThis.' + slot + ')', context, { filename: 'flow-serialize.js', timeout: remaining() });
+    } catch (error) {
+      if (error && error.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT') return timedOut(false);
       return failure(keys.outputInvalid, { node: job.node }, 'The code returned a value that is not JSON.', logs);
     }
-    const json = vm.getString(keep(serialized.value));
     if (Buffer.byteLength(json, 'utf8') > limits.outputBytes) {
       return failure(keys.outputTooLarge, { node: job.node, bytes: limits.outputBytes }, 'The code output is larger than ' + limits.outputBytes + ' bytes.', logs);
     }
     return { json, logs };
   } catch (error) {
-    if (error && error.failure) return error;
-    const detail = String((error && error.message) || error).slice(0, limits.logLineChars);
+    // Work the code left running after its deadline would carry on into the next run, so that worker is replaced.
+    if (error === TIMED_OUT) return timedOut(true);
+    if (error && error.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT') return timedOut(false);
+    const detail = describe(error);
     return failure(keys.threw, { node: job.node, detail }, detail, logs);
   } finally {
-    for (let i = handles.length - 1; i >= 0; i--) {
-      if (handles[i].alive) handles[i].dispose();
-    }
-    vm.dispose();
-    runtime.dispose();
+    clearTimeout(watch);
+    for (const handle of timers.values()) clearTimeout(handle);
+    timers.clear();
+    fetches.clear();
   }
 }
 
-parentPort.on('message', async (job) => {
-  let module;
-  try {
-    module = await load();
-  } catch (error) {
-    const detail = 'The code sandbox could not be loaded: ' + String((error && error.message) || error);
-    parentPort.postMessage({ id: job.id, ...failure(keys.unavailable, { node: job.node }, detail, []) });
+parentPort.on('message', async (message) => {
+  if (message.type === 'fetch') {
+    const pending = fetches.get(message.call);
+    if (!pending) return;
+    fetches.delete(message.call);
+    if (message.error !== undefined) pending.reject(new Error(message.error));
+    else pending.resolve(message.json);
     return;
   }
-  parentPort.postMessage({ id: job.id, ...run(module, job) });
+  parentPort.postMessage({ type: 'done', id: message.id, ...(await run(message)) });
 });
 `;
-const CODE_SANDBOX_LIMITS = {
+const CODE_RUNNER_LIMITS = {
     MAX_WORKERS: Math.max(1, Math.min(4, (0,__rspack_external_node_os_4f3c9d58.availableParallelism)() - 1)),
     MAX_QUEUED_RUNS: 200,
-    /** Extra time the host waits past the in-sandbox deadline before killing the worker thread. */ WATCHDOG_GRACE_MS: 1000,
-    WORKER_HEAP_MB: 64
+    /** Extra time the host waits past the code's deadline before killing the worker thread. */ WATCHDOG_GRACE_MS: 1000,
+    /** How often the host checks a running worker's memory: buffers live outside the heap limit a worker can set itself. */ MEMORY_CHECK_MS: 20
 };
-/** Where the worker resolves `quickjs-emscripten` from: this module's own file first, then the app. */ function resolutionBases() {
+/** Where the worker resolves the configured packages from: this module's own file first, then the app. */ function resolutionBases() {
     const bases = [];
     const original = Error.prepareStackTrace;
     try {
@@ -297,39 +354,51 @@ const CODE_SANDBOX_LIMITS = {
 const WORKER_DATA = {
     bases: resolutionBases(),
     prelude: PRELUDE,
-    serialize: SERIALIZE,
     sensitive: redact/* .SENSITIVE_KEY.source */.X6.source,
     limits: {
-        memoryBytes: flow_types/* .FLOW_LIMITS.CODE_MEMORY_LIMIT_BYTES */.Or.CODE_MEMORY_LIMIT_BYTES,
-        stackBytes: flow_types/* .FLOW_LIMITS.CODE_STACK_SIZE_BYTES */.Or.CODE_STACK_SIZE_BYTES,
         outputBytes: flow_types/* .FLOW_LIMITS.MAX_CODE_OUTPUT_BYTES */.Or.MAX_CODE_OUTPUT_BYTES,
         logLines: flow_types/* .FLOW_LIMITS.MAX_CODE_LOG_LINES */.Or.MAX_CODE_LOG_LINES,
         logLineChars: flow_types/* .FLOW_LIMITS.MAX_CODE_LOG_LINE_CHARS */.Or.MAX_CODE_LOG_LINE_CHARS
     },
     keys: {
-        unavailable: message_keys/* .FLOW_ERROR_MESSAGES.CODE_UNAVAILABLE */.zr.CODE_UNAVAILABLE,
         threw: message_keys/* .FLOW_ERROR_MESSAGES.CODE_THREW */.zr.CODE_THREW,
         timeout: message_keys/* .FLOW_ERROR_MESSAGES.CODE_TIMEOUT */.zr.CODE_TIMEOUT,
-        outOfMemory: message_keys/* .FLOW_ERROR_MESSAGES.CODE_OUT_OF_MEMORY */.zr.CODE_OUT_OF_MEMORY,
         outputInvalid: message_keys/* .FLOW_ERROR_MESSAGES.CODE_OUTPUT_INVALID */.zr.CODE_OUTPUT_INVALID,
         outputTooLarge: message_keys/* .FLOW_ERROR_MESSAGES.CODE_OUTPUT_TOO_LARGE */.zr.CODE_OUTPUT_TOO_LARGE
     }
 };
+/** The worker gets none of the server's secrets: only the variables packages commonly read. */ function workerEnv() {
+    return Object.fromEntries([
+        'NODE_ENV',
+        'TZ',
+        'LANG'
+    ].flatMap((name)=>process.env[name] ? [
+            [
+                name,
+                process.env[name]
+            ]
+        ] : []));
+}
+const MEMORY_MB = flow_types/* .FLOW_LIMITS.CODE_MEMORY_LIMIT_BYTES */.Or.CODE_MEMORY_LIMIT_BYTES / (1024 * 1024);
 const timeoutError = (job)=>new flow_errors/* .FlowCodeError */.yL(message_keys/* .FLOW_ERROR_MESSAGES.CODE_TIMEOUT */.zr.CODE_TIMEOUT, {
         node: job.node,
         ms: job.timeoutMs
     }, `The code ran longer than ${job.timeoutMs} ms.`);
+const outOfMemoryError = (job)=>new flow_errors/* .FlowCodeError */.yL(message_keys/* .FLOW_ERROR_MESSAGES.CODE_OUT_OF_MEMORY */.zr.CODE_OUT_OF_MEMORY, {
+        node: job.node,
+        mb: MEMORY_MB
+    }, `The code used more than ${MEMORY_MB} MB of memory.`);
 const unavailableError = (node, detail)=>new flow_errors/* .FlowCodeError */.yL(message_keys/* .FLOW_ERROR_MESSAGES.CODE_UNAVAILABLE */.zr.CODE_UNAVAILABLE, {
         node
-    }, `The code sandbox could not run the code: ${detail}`);
-let flow_code_sandbox_CodeSandboxPool = class CodeSandboxPool {
+    }, `The code runner could not run the code: ${detail}`);
+let flow_code_runner_CodeRunnerPool = class CodeRunnerPool {
     idle = [];
     running = new Map();
     queue = [];
     workers = 0;
     nextId = 1;
-    run(code, input, timeoutMs, node) {
-        if (this.queue.length >= CODE_SANDBOX_LIMITS.MAX_QUEUED_RUNS) {
+    run(code, input, timeoutMs, node, options) {
+        if (this.queue.length >= CODE_RUNNER_LIMITS.MAX_QUEUED_RUNS) {
             return Promise.reject(unavailableError(node, 'too many code steps are waiting to run.'));
         }
         return new Promise((resolve, reject)=>{
@@ -339,6 +408,8 @@ let flow_code_sandbox_CodeSandboxPool = class CodeSandboxPool {
                 input,
                 timeoutMs,
                 node,
+                modules: options.modules ?? {},
+                http: options.http,
                 resolve,
                 reject
             });
@@ -346,7 +417,7 @@ let flow_code_sandbox_CodeSandboxPool = class CodeSandboxPool {
         });
     }
     dispatch() {
-        while(this.queue.length && (this.idle.length || this.workers < CODE_SANDBOX_LIMITS.MAX_WORKERS)){
+        while(this.queue.length && (this.idle.length || this.workers < CODE_RUNNER_LIMITS.MAX_WORKERS)){
             const job = this.queue.shift();
             let worker;
             try {
@@ -361,66 +432,96 @@ let flow_code_sandbox_CodeSandboxPool = class CodeSandboxPool {
     start(worker, job) {
         this.running.set(worker, job);
         worker.ref();
-        job.watchdog = setTimeout(()=>{
-            this.running.delete(worker);
-            job.reject(timeoutError(job));
-            void worker.terminate();
-        }, job.timeoutMs + CODE_SANDBOX_LIMITS.WATCHDOG_GRACE_MS);
+        job.watchdog = setTimeout(()=>this.kill(worker, job, timeoutError(job)), job.timeoutMs + CODE_RUNNER_LIMITS.WATCHDOG_GRACE_MS);
+        job.memoryWatch = setInterval(()=>{
+            worker.getHeapStatistics().then((stats)=>{
+                const external = stats.external_memory ?? 0;
+                if (stats.used_heap_size + external > flow_types/* .FLOW_LIMITS.CODE_MEMORY_LIMIT_BYTES */.Or.CODE_MEMORY_LIMIT_BYTES) this.kill(worker, job, outOfMemoryError(job));
+            }, ()=>undefined);
+        }, CODE_RUNNER_LIMITS.MEMORY_CHECK_MS);
         // oxlint-disable-next-line unicorn/require-post-message-target-origin -- a worker_threads Worker has no origin
         worker.postMessage({
             id: job.id,
             code: job.code,
             input: job.input,
             timeoutMs: job.timeoutMs,
-            node: job.node
+            node: job.node,
+            modules: job.modules
         });
     }
+    kill(worker, job, error) {
+        if (this.running.get(worker) !== job) return;
+        this.take(worker);
+        job.reject(error);
+        void worker.terminate();
+    }
     spawn() {
         const worker = new __rspack_external_node_worker_threads_28ca7740.Worker(WORKER_SOURCE, {
             eval: true,
             workerData: WORKER_DATA,
+            env: workerEnv(),
             resourceLimits: {
-                maxOldGenerationSizeMb: CODE_SANDBOX_LIMITS.WORKER_HEAP_MB
+                maxOldGenerationSizeMb: MEMORY_MB
             }
         });
         this.workers++;
-        worker.on('message', (reply)=>this.settle(worker, reply));
+        worker.on('message', (message)=>message.type === 'fetch' ? this.fetch(worker, message) : this.settle(worker, message));
         worker.on('error', (error)=>{
             const job = this.take(worker);
             if (!job) return;
-            if (error.code === 'ERR_WORKER_OUT_OF_MEMORY') {
-                const mb = flow_types/* .FLOW_LIMITS.CODE_MEMORY_LIMIT_BYTES */.Or.CODE_MEMORY_LIMIT_BYTES / (1024 * 1024);
-                job.reject(new flow_errors/* .FlowCodeError */.yL(message_keys/* .FLOW_ERROR_MESSAGES.CODE_OUT_OF_MEMORY */.zr.CODE_OUT_OF_MEMORY, {
-                    node: job.node,
-                    mb
-                }, `The code used more than ${mb} MB of memory.`));
-            } else {
-                job.reject(unavailableError(job.node, error.message));
-            }
+            job.reject(error.code === 'ERR_WORKER_OUT_OF_MEMORY' ? outOfMemoryError(job) : unavailableError(job.node, error.message));
         });
         worker.on('exit', ()=>{
             this.workers--;
             const index = this.idle.indexOf(worker);
             if (index >= 0) this.idle.splice(index, 1);
             const job = this.take(worker);
-            job?.reject(unavailableError(job.node, 'the sandbox worker stopped.'));
+            job?.reject(unavailableError(job.node, 'the code worker stopped.'));
             this.dispatch();
         });
         return worker;
     }
+    fetch(worker, message) {
+        const job = this.running.get(worker);
+        if (!job || job.id !== message.id) return;
+        const reply = (answer)=>{
+            // oxlint-disable-next-line unicorn/require-post-message-target-origin -- a worker_threads Worker has no origin
+            if (this.running.get(worker) === job) worker.postMessage({
+                type: 'fetch',
+                call: message.call,
+                ...answer
+            });
+        };
+        if (!job.http) {
+            reply({
+                error: 'fetch is not available here.'
+            });
+            return;
+        }
+        job.http(message.request).then((response)=>reply({
+                json: JSON.stringify(response)
+            }), (error)=>reply({
+                error: error instanceof Error ? error.message : String(error)
+            }));
+    }
     take(worker) {
         const job = this.running.get(worker);
         if (!job) return undefined;
         this.running.delete(worker);
         clearTimeout(job.watchdog);
+        clearInterval(job.memoryWatch);
         return job;
     }
     settle(worker, reply) {
         const job = this.running.get(worker);
         if (!job || job.id !== reply.id) return;
         this.take(worker);
-        worker.unref();
-        this.idle.push(worker);
+        if (reply.recycle) {
+            void worker.terminate();
+        } else {
+            worker.unref();
+            this.idle.push(worker);
+        }
         if (reply.failure) {
             const { key, vars, detail, logs } = reply.failure;
             job.reject(new flow_errors/* .FlowCodeError */.yL(key, vars, detail, logs));
@@ -435,14 +536,16 @@ let flow_code_sandbox_CodeSandboxPool = class CodeSandboxPool {
 };
 let pool;
 /**
- * Runs author-written JavaScript in a QuickJS (WebAssembly) sandbox on a worker thread: a fresh
- * runtime + context per run, a memory limit, a stack limit and an interrupt deadline, plus a host
- * watchdog that kills the worker if the deadline is overrun. Nothing of the host is reachable -
- * no require/process/network/filesystem - except a console.log that is captured. The code gets a
- * frozen JSON copy of its input as `ctx` and must return JSON-serializable data.
- * `hasPermission` / `hasAnyPermission` / `hasAllPermissions` are plain JavaScript inside the sandbox,
- * reading `ctx.user.permissions` with the same `*` / `prefix.*` wildcards as the server.
- */ async function runSandboxedCode(code, ctx, timeoutMs, node) {
+ * Runs author-written JavaScript on the server, in Node, on a worker thread (a small pool, so a
+ * busy code step never blocks the event loop). Each run gets a fresh `vm` context holding a frozen
+ * JSON copy of its input as `ctx`, a captured `console`, the permission helpers, `require` for the
+ * packages the app allows, a `fetch` the host carries out with the HTTP step's rules, timers, and
+ * the common web globals. The code body is async and must return JSON-serializable data.
+ * Limits: the time limit (synchronous code is interrupted; a run still busy after it plus a grace
+ * period has its worker killed), the worker's memory (heap plus buffers, checked by the host) and
+ * the output size. The worker sees none of the server's env variables. This is not a security
+ * boundary: a package's objects lead back to Node itself, so code steps are for trusted authors.
+ */ async function runFlowCode(code, ctx, timeoutMs, node, options = {}) {
     let input;
     try {
         input = JSON.stringify(ctx) ?? '{}';
@@ -452,12 +555,14 @@ let pool;
             detail: error.message
         }, error.message);
     }
-    pool ??= new flow_code_sandbox_CodeSandboxPool();
-    return pool.run(code, input, timeoutMs, node);
+    pool ??= new flow_code_runner_CodeRunnerPool();
+    return pool.run(code, input, timeoutMs, node, options);
 }
 
 // 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-input.validator.ts
+var flow_input_validator = __webpack_require__(6390);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-values.ts
 var rule_values = __webpack_require__(6622);
 ;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-node-handlers.ts
@@ -469,6 +574,7 @@ var rule_values = __webpack_require__(6622);
 
 
 
+
 /** With `env`, `lookup` expressions read through the flow (its transaction). */ function evaluationContext(state, env) {
     const base = {
         input: state.input,
@@ -678,7 +784,7 @@ async function isGrantedScope(userId, companyId, branchId, env) {
     ]);
 }
 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) {
+/** The caller as a code step sees it; permission codes (current branch) are fetched only for code that reads them. */ async function codeUser(code, env, state) {
     const user = state.user;
     if (!user) return null;
     const base = {
@@ -689,12 +795,27 @@ const USES_PERMISSIONS = /\b(permissions|hasPermission|hasAnyPermission|hasAllPe
         branchId: user.branchId ?? null
     };
     if (!USES_PERMISSIONS.test(code)) return base;
+    const permissions = state.permissions ?? env.ruleEngine.createPermissionResolver(user);
     return {
         ...base,
-        permissions: await state.permissions?.granted(undefined) ?? []
+        permissions: await permissions.granted(undefined)
     };
 }
-async function runCode(node, cfg, state) {
+/** The code's `fetch`, held to the rules of an HTTP request step: skipped in a test run, counted, private addresses refused. */ function codeHttp(env, state) {
+    return (request)=>{
+        if (state.mode === 'dry_run') return Promise.reject(new Error('fetch does not run in a test run, like an HTTP request step.'));
+        if (++state.httpCalls > flow_types/* .FLOW_LIMITS.MAX_HTTP_CALLS */.Or.MAX_HTTP_CALLS) return Promise.reject(new flow_errors/* .FlowLimitError */.IM(message_keys/* .FLOW_ERROR_MESSAGES.TOO_MANY_HTTP_CALLS */.zr.TOO_MANY_HTTP_CALLS, {
+            max: flow_types/* .FLOW_LIMITS.MAX_HTTP_CALLS */.Or.MAX_HTTP_CALLS
+        }));
+        const timeoutMs = Math.max(1, Math.min(flow_types/* .FLOW_LIMITS.MAX_HTTP_TIMEOUT_MS */.Or.MAX_HTTP_TIMEOUT_MS, state.deadline - Date.now()));
+        return env.http({
+            ...request,
+            timeoutMs,
+            allowPrivate: env.allowPrivateHttp
+        });
+    };
+}
+async function runCode(node, cfg, env, state) {
     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);
     const timeoutMs = Math.min(cfg.timeoutMs ?? flow_types/* .FLOW_LIMITS.DEFAULT_CODE_TIMEOUT_MS */.Or.DEFAULT_CODE_TIMEOUT_MS, flow_types/* .FLOW_LIMITS.MAX_CODE_TIMEOUT_MS */.Or.MAX_CODE_TIMEOUT_MS, remaining);
@@ -703,9 +824,12 @@ async function runCode(node, cfg, state) {
         vars: state.vars,
         context: state.context,
         loop: state.loop ?? null,
-        user: await codeUser(cfg.code, state)
+        user: await codeUser(cfg.code, env, state)
     };
-    const { output, logs } = await runSandboxedCode(cfg.code, ctx, timeoutMs, (0,flow_types/* .nodeLabel */.dA)(node));
+    const { output, logs } = await runFlowCode(cfg.code, ctx, timeoutMs, (0,flow_types/* .nodeLabel */.dA)(node), {
+        modules: env.codeModules,
+        http: codeHttp(env, state)
+    });
     return {
         output,
         ...logs.length ? {
@@ -723,7 +847,136 @@ function writeOptions(state) {
     return state.qr ? {
         queryRunner: state.qr,
         publishEvents: false
+    } : {
+        statementTimeoutMs: state.deadline - Date.now()
+    };
+}
+/** A get_all request's own query: what a `fromRequest` step reads, checked by the get_all rules whatever the Request step's type. A list body has none. */ function requestQuery(state) {
+    const { query, errors } = (0,flow_input_validator/* .readRequestQuery */.M2)(state.input);
+    if (errors.length) throw new flow_errors/* .FlowHttpError */.hk(400, 'Validation failed', errors, {
+        messageKey: message_keys/* .FLOW_MESSAGES.INPUT_INVALID */.wu.INPUT_INVALID
+    });
+    return query;
+}
+/** A request's filter the way the API controller reads it: a value matches as equal, a list as one of its items - never an operator the caller sent. */ function requestFilter(filter) {
+    return Object.fromEntries(Object.entries(filter ?? {}).map(([key, value])=>[
+            key,
+            {
+                op: Array.isArray(value) ? 'in' : 'eq',
+                value
+            }
+        ]));
+}
+/** Only the fields a request's `select` names, `id` always kept; every field when it names none. */ function selectFields(rows, select) {
+    if (!select?.length) return rows;
+    const kept = new Set([
+        'id',
+        ...select
+    ]);
+    return rows.map((row)=>Object.fromEntries(Object.entries(row).filter(([key])=>kept.has(key))));
+}
+async function runQuery(node, cfg, env, state) {
+    const ctx = evaluationContext(state, env);
+    const service = await env.entityService(cfg.entityCode, state.qr);
+    const request = cfg.fromRequest ? requestQuery(state) : {};
+    const filter = {
+        ...requestFilter(request.filter),
+        ...await mapFilter(node, cfg.filter, env, state, 'skip')
+    };
+    const searched = cfg.search ? await env.ruleEngine.resolveExpression(cfg.search, ctx) : cfg.fromRequest ? state.request['query']?.['q'] : undefined;
+    const search = typeof searched === 'string' && searched ? searched : undefined;
+    const sort = cfg.sort ? {
+        [cfg.sort.field]: cfg.sort.direction === 'DESC' ? 'DESC' : 'ASC'
+    } : request.sort;
+    const page = request.pagination?.currentPage ?? 0;
+    const pageSize = Math.min(request.pagination?.pageSize ?? cfg.limit ?? flow_types/* .FLOW_LIMITS.DEFAULT_QUERY_LIMIT */.Or.DEFAULT_QUERY_LIMIT, flow_types/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT);
+    const withDeleted = request.withDeleted === true ? {
+        withDeleted: true
     } : {};
+    const { data, total } = await service.getAll(search, {
+        filter,
+        sort,
+        pagination: {
+            currentPage: page,
+            pageSize
+        },
+        ...withDeleted
+    }, readOptions(state));
+    return {
+        output: {
+            items: selectFields(data, request.select),
+            total,
+            page,
+            pageSize
+        }
+    };
+}
+/** A Respond step's body: as built (raw), or the API controller envelope around it. */ async function respondBody(node, cfg, env, state) {
+    const ctx = evaluationContext(state, env);
+    const format = cfg.format ?? 'raw';
+    const built = async ()=>cfg.bodyExpression ? env.ruleEngine.resolveExpression(cfg.bodyExpression, ctx) : mapValues(cfg.body, env, state);
+    if (format === 'raw') return built();
+    const variables = await mapValues(cfg.messageVariables, env, state);
+    const envelope = {
+        success: cfg.statusCode < 400,
+        message: cfg.message ?? '',
+        messageKey: cfg.messageKey ?? '',
+        ...Object.keys(variables).length ? {
+            messageVariables: variables
+        } : {}
+    };
+    if (format === 'message') return envelope;
+    if (format === 'single') return {
+        ...envelope,
+        data: await built()
+    };
+    const value = await built();
+    if (value !== null && value !== undefined && !Array.isArray(value)) throw new flow_errors/* .FlowKeyedError */.Hp(message_keys/* .FLOW_ERROR_MESSAGES.RESPOND_DATA_NOT_LIST */.zr.RESPOND_DATA_NOT_LIST, {
+        node: (0,flow_types/* .nodeLabel */.dA)(node)
+    });
+    const data = value ?? [];
+    const count = async (name, fallback)=>{
+        const expression = cfg[name];
+        if (expression === undefined) return fallback;
+        const resolved = await env.ruleEngine.resolveExpression(expression, ctx);
+        if (resolved === null || resolved === undefined || resolved === '') return fallback;
+        const n = Number(resolved);
+        if (!Number.isInteger(n) || n < 0) throw new flow_errors/* .FlowKeyedError */.Hp(message_keys/* .FLOW_ERROR_MESSAGES.RESPOND_META_INVALID */.zr.RESPOND_META_INVALID, {
+            node: (0,flow_types/* .nodeLabel */.dA)(node),
+            name
+        });
+        return n;
+    };
+    if (format === 'bulk') {
+        const total = await count('total', Array.isArray(state.input) ? state.input.length : data.length);
+        return {
+            ...envelope,
+            data,
+            meta: {
+                count: data.length,
+                total,
+                failed: Math.max(total - data.length, 0)
+            }
+        };
+    }
+    // Only the defaults of the list meta: a request whose paging cannot be read falls back to them.
+    const pagination = (0,flow_input_validator/* .readRequestQuery */.M2)(state.input).query.pagination;
+    const total = await count('total', data.length);
+    const page = await count('page', pagination?.currentPage ?? 0);
+    const pageSize = await count('pageSize', pagination?.pageSize ?? data.length);
+    const totalPages = pageSize > 0 ? Math.ceil(total / pageSize) : 1;
+    return {
+        ...envelope,
+        data,
+        meta: {
+            total,
+            page,
+            pageSize,
+            count: data.length,
+            hasMore: page < totalPages - 1,
+            totalPages
+        }
+    };
 }
 function readOptions(state) {
     return {
@@ -793,6 +1046,20 @@ async function updateRecord(entityCode, service, values, state) {
     });
     return saved;
 }
+/** An update by filter's match: the row was just read on this transaction, so the service need not read it again. */ async function updateMatched(entityCode, service, row, values, state) {
+    if (!service.updateLoaded) return updateRecord(entityCode, service, {
+        ...values,
+        id: row.id
+    }, state);
+    countWrite(state);
+    const saved = await service.updateLoaded(row, values, state.user, writeOptions(state));
+    if (state.qr) state.pendingEvents.push({
+        entityCode,
+        action: 'updated',
+        row: saved
+    });
+    return saved;
+}
 /** @returns false when the record does not exist and `skip` allows that. */ async function deleteRecord(entityCode, service, id, skipMissing, state) {
     countWrite(state);
     let action;
@@ -822,11 +1089,12 @@ async function updateRecord(entityCode, service, values, state) {
         });
     }
     const limit = Math.min(cfg.limit ?? flow_types/* .FLOW_LIMITS.DEFAULT_WRITE_FILTER_LIMIT */.Or.DEFAULT_WRITE_FILTER_LIMIT, flow_types/* .FLOW_LIMITS.MAX_WRITE_ITEMS */.Or.MAX_WRITE_ITEMS);
+    // One row past the limit: getAll then counts only when there are too many, to name how many.
     const { data, total } = await service.getAll(undefined, {
         filter,
         pagination: {
             currentPage: 0,
-            pageSize: limit
+            pageSize: limit + 1
         }
     }, readOptions(state));
     if (total > limit) throw new flow_errors/* .FlowLimitError */.IM(message_keys/* .FLOW_ERROR_MESSAGES.TOO_MANY_MATCHES */.zr.TOO_MANY_MATCHES, {
@@ -862,6 +1130,9 @@ async function insertChildren(node, child, parentId, env, state) {
     if (writeTarget(cfg) === 'one') return {
         output: children.length ? await env.atomic(state, insertOne) : await insertOne()
     };
+    if (!children.length && insertsInBatch(service, cfg)) return {
+        output: await env.atomic(state, ()=>insertBatch(node, cfg, service, env, state))
+    };
     return {
         output: await env.atomic(state, async ()=>{
             const items = await eachItem(state, await resolveList(node, cfg.items, flow_types/* .FLOW_LIMITS.MAX_WRITE_ITEMS */.Or.MAX_WRITE_ITEMS, env, state), insertOne);
@@ -872,6 +1143,54 @@ async function insertChildren(node, child, parentId, env, state) {
         })
     };
 }
+/** A field mapping that reads records (a lookup) must see the rows inserted before it, so it keeps the row-by-row insert. */ function readsRecords(value) {
+    if (Array.isArray(value)) return value.some(readsRecords);
+    if (!value || typeof value !== 'object') return false;
+    return value.type === 'lookup' || Object.values(value).some(readsRecords);
+}
+function insertsInBatch(service, cfg) {
+    return service.batchInsertable === true && !!service.prepareInsert && !!service.firstMissingRelation && !!service.insertValidated && !readsRecords(cfg.fields);
+}
+/**
+ * `many` in one statement per chunk, answering exactly as row by row would: each row's values are mapped, counted
+ * and checked in order, and the first row that would have failed (a mapping, a check or a missing related record)
+ * is the failure reported, with the write count it had reached.
+ */ async function insertBatch(node, cfg, service, env, state) {
+    const items = await resolveList(node, cfg.items, flow_types/* .FLOW_LIMITS.MAX_WRITE_ITEMS */.Or.MAX_WRITE_ITEMS, env, state);
+    const writesBefore = state.writes;
+    const rows = [];
+    let failure;
+    try {
+        await eachItem(state, items, async ()=>{
+            const values = await mapFieldValues(cfg.fields, env, state);
+            countWrite(state);
+            rows.push(service.prepareInsert(values));
+        });
+    } catch (error) {
+        failure = {
+            error
+        };
+    }
+    const missing = await service.firstMissingRelation(rows, state.qr);
+    if (missing) {
+        state.writes = writesBefore + missing.index + 1;
+        throw missing.error;
+    }
+    if (failure) throw failure.error;
+    const saved = await service.insertValidated(rows, state.user, {
+        queryRunner: state.qr,
+        publishEvents: false
+    });
+    for (const row of saved)state.pendingEvents.push({
+        entityCode: cfg.entityCode,
+        action: 'created',
+        row
+    });
+    return {
+        items: saved,
+        count: saved.length
+    };
+}
 /** Updates the record `id` names; one that does not exist (or an empty id, for insert) is handled as `onNotFound` says. */ async function updateOrCreate(cfg, service, fallbackId, env, state) {
     const onNotFound = cfg.onNotFound ?? 'error';
     const raw = cfg.id === undefined ? fallbackId : await env.ruleEngine.resolveExpression(cfg.id, evaluationContext(state, env));
@@ -909,10 +1228,7 @@ async function insertChildren(node, child, parentId, env, state) {
     return {
         output: await env.atomic(state, async ()=>{
             const outcomes = target === 'filter' ? await eachItem(state, await matchingRecords(node, cfg, service, env, state), async (row)=>({
-                    row: await updateRecord(cfg.entityCode, service, {
-                        ...await mapFieldValues(cfg.fields, env, state),
-                        id: row.id
-                    }, state),
+                    row: await updateMatched(cfg.entityCode, service, row, await mapFieldValues(cfg.fields, env, state), state),
                     result: 'updated'
                 })) : await eachItem(state, await resolveList(node, cfg.items, flow_types/* .FLOW_LIMITS.MAX_WRITE_ITEMS */.Or.MAX_WRITE_ITEMS, env, state), (item)=>updateOrCreate(cfg, service, itemId(item), env, state));
             const items = outcomes.flatMap((o)=>o.row ? [
@@ -1343,7 +1659,7 @@ const nobody = (extra = {})=>({
         case 'validate':
             return runValidate(c, env, state);
         case 'code':
-            return runCode(node, c, state);
+            return runCode(node, c, env, state);
         case 'permission_check':
             return runPermissionCheck(c, env, state);
         case 'company_branch_check':
@@ -1407,8 +1723,11 @@ const nobody = (extra = {})=>({
                 const id = asId(await env.ruleEngine.resolveExpression(cfg.id, ctx));
                 const service = await env.entityService(cfg.entityCode, state.qr);
                 try {
+                    const record = await service.findById(id, readOptions(state));
                     return {
-                        output: await service.findById(id, readOptions(state))
+                        output: cfg.fromRequest ? selectFields([
+                            record
+                        ], requestQuery(state).select)[0] : record
                     };
                 } catch (error) {
                     if (error instanceof common_.NotFoundException && cfg.onNotFound === 'null') return {
@@ -1418,29 +1737,7 @@ const nobody = (extra = {})=>({
                 }
             }
         case 'entity_query':
-            {
-                const cfg = c;
-                const service = await env.entityService(cfg.entityCode, state.qr);
-                const filter = await mapFilter(node, cfg.filter, env, state, 'skip');
-                const search = cfg.search ? await env.ruleEngine.resolveExpression(cfg.search, ctx) : undefined;
-                const limit = Math.min(cfg.limit ?? 50, flow_types/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT);
-                const { data, total } = await service.getAll(typeof search === 'string' && search ? search : undefined, {
-                    filter,
-                    sort: cfg.sort ? {
-                        [cfg.sort.field]: cfg.sort.direction === 'DESC' ? 'DESC' : 'ASC'
-                    } : undefined,
-                    pagination: {
-                        currentPage: 0,
-                        pageSize: limit
-                    }
-                }, readOptions(state));
-                return {
-                    output: {
-                        items: data,
-                        total
-                    }
-                };
-            }
+            return runQuery(node, c, env, state);
         case 'commit':
             {
                 const reasonKey = state.mode === 'dry_run' ? message_keys/* .FLOW_SKIP_MESSAGES.COMMIT_DRY_RUN */.CB.COMMIT_DRY_RUN : !state.qr ? message_keys/* .FLOW_SKIP_MESSAGES.COMMIT_NO_TRANSACTION */.CB.COMMIT_NO_TRANSACTION : !state.ownsTransaction ? message_keys/* .FLOW_SKIP_MESSAGES.COMMIT_JOINED */.CB.COMMIT_JOINED : null;
@@ -1542,7 +1839,7 @@ const nobody = (extra = {})=>({
         case 'respond':
             {
                 const cfg = c;
-                const body = cfg.bodyExpression ? await env.ruleEngine.resolveExpression(cfg.bodyExpression, ctx) : await mapValues(cfg.body, env, state);
+                const body = await respondBody(node, cfg, env, state);
                 return {
                     output: body,
                     respond: {
@@ -2203,19 +2500,29 @@ function conditionProblem(node, options) {
     const warnings = [];
     const err = (message)=>errors.push(message);
     if (!_flow_types_js__rspack_import_5/* .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));
-    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_7/* .FLOW_VALIDATION_MESSAGES.NO_NODES */.qj.NO_NODES));
-    if (nodes.length > _flow_types_js__rspack_import_5/* .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, {
+    const allNodes = Array.isArray(flow.nodes) ? flow.nodes : [];
+    const allEdges = Array.isArray(flow.edges) ? flow.edges : [];
+    if (!allNodes.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 (allNodes.length > _flow_types_js__rspack_import_5/* .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_5/* .FLOW_LIMITS.MAX_NODES */.Or.MAX_NODES
     }));
-    if (edges.length > _flow_types_js__rspack_import_5/* .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, {
+    if (allEdges.length > _flow_types_js__rspack_import_5/* .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_5/* .FLOW_LIMITS.MAX_EDGES */.Or.MAX_EDGES
     }));
-    if (errors.length && (!nodes.length || nodes.length > _flow_types_js__rspack_import_5/* .FLOW_LIMITS.MAX_NODES */.Or.MAX_NODES || edges.length > _flow_types_js__rspack_import_5/* .FLOW_LIMITS.MAX_EDGES */.Or.MAX_EDGES)) return {
+    if (errors.length && (!allNodes.length || allNodes.length > _flow_types_js__rspack_import_5/* .FLOW_LIMITS.MAX_NODES */.Or.MAX_NODES || allEdges.length > _flow_types_js__rspack_import_5/* .FLOW_LIMITS.MAX_EDGES */.Or.MAX_EDGES)) return {
         errors,
         warnings
     };
+    const isEntry = (item)=>!!item && typeof item === 'object';
+    const nodes = allNodes.filter(isEntry);
+    const edges = allEdges.filter(isEntry);
+    if (nodes.length < allNodes.length) 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: undefined
+    }));
+    if (edges.length < allEdges.length) 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: undefined,
+        to: undefined
+    }));
     const byId = new Map();
     for (const node of nodes){
         if (!_flow_types_js__rspack_import_5/* .FLOW_NODE_ID_PATTERN.test */.z6.test(node?.id ?? '')) {
@@ -2313,7 +2620,7 @@ function conditionProblem(node, options) {
 }
 /** The entities a step reads or writes: its own, its child inserts' and those its lookups read. */ function entitiesOf(node) {
     const codes = collectLookupEntities(node.config);
-    if (node.type.startsWith('entity_') && typeof node.config?.['entityCode'] === 'string') codes.add(node.config['entityCode']);
+    if (String(node.type).startsWith('entity_') && typeof node.config?.['entityCode'] === 'string') codes.add(node.config['entityCode']);
     const children = node.type === 'entity_insert' && Array.isArray(node.config?.['children']) ? node.config['children'] : [];
     for (const child of children)if (typeof child?.entityCode === 'string') codes.add(child.entityCode);
     return [
@@ -2343,6 +2650,17 @@ function conditionProblem(node, options) {
             }));
         }
         if (endpoint.authMode === 'public' && steps.some((n)=>(0,_flow_types_js__rspack_import_5/* .isMessageNode */.SE)(n.type))) warnOnce((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.PUBLIC_MESSAGE */.qj.PUBLIC_MESSAGE));
+        for (const n of steps){
+            if (n.config?.['fromRequest'] !== true) continue;
+            if (n.type === 'entity_query' && endpoint.contract !== 'get_all' && endpoint.contract !== 'get_by_ids') warnOnce((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_QUERY_NOT_GET_ALL */.qj.NODE_QUERY_NOT_GET_ALL, {
+                node: (0,_flow_types_js__rspack_import_5/* .nodeLabel */.dA)(n),
+                endpoint: label
+            }));
+            if (n.type === 'entity_get' && endpoint.contract !== 'get_by_id') warnOnce((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_GET_NOT_GET_BY_ID */.qj.NODE_GET_NOT_GET_BY_ID, {
+                node: (0,_flow_types_js__rspack_import_5/* .nodeLabel */.dA)(n),
+                endpoint: label
+            }));
+        }
         // A URL callers reach without signing in has no user: user checks deny them, and its record steps are open to anyone who can call it.
         if (!_flow_types_js__rspack_import_5/* .KEYLESS_AUTH_MODES.has */.d7.has(endpoint.authMode)) continue;
         if (steps.some((n)=>(n.type === 'permission_check' || n.type === 'company_branch_check') && n.config?.['subject'] !== 'user' || usesPermissionFunction(n.config))) warnOnce((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));
@@ -2526,6 +2844,12 @@ function conditionProblem(node, options) {
         validateInputFields(field.fields, itemType === 'object' ? `${name}[].` : `${name}.`, depth + 1, err);
     }
 }
+const REQUIRE_CALL = /\brequire\s*\(\s*(['"`])([^'"`\n]+)\1\s*\)/g;
+/** The package names a code step asks for with a literal `require('name')`. */ function requiredPackages(code) {
+    return [
+        ...code.matchAll(REQUIRE_CALL)
+    ].map((match)=>match[2]);
+}
 function validateNodeConfig(node, flow, context, err, warn) {
     const at = {
         node: (0,_flow_types_js__rspack_import_5/* .nodeLabel */.dA)(node)
@@ -2624,6 +2948,10 @@ function validateNodeConfig(node, flow, context, err, warn) {
         template: {
             list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.TEMPLATE_VALUES */.bc.TEMPLATE_VALUES,
             item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.TEMPLATE_VALUE */.bc.TEMPLATE_VALUE
+        },
+        messageVariable: {
+            list: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.MESSAGE_VARIABLES */.bc.MESSAGE_VARIABLES,
+            item: _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.MESSAGE_VARIABLE */.bc.MESSAGE_VARIABLE
         }
     };
     const optionalExpr = (value, what)=>{
@@ -2640,6 +2968,8 @@ function validateNodeConfig(node, flow, context, err, warn) {
     const serviceRunning = (service, unavailable)=>{
         if (context.messageServices && !context.messageServices[service]) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(unavailable, at));
     };
+    // A failure carried past a step with no `error` port would follow `out`, which such a step does not have (or, for a check, is never carried past).
+    if (node.onError === 'continue' && node.type !== 'commit' && (node.type === 'switch' || !(0,_flow_types_js__rspack_import_5/* .portsOf */.a5)(node).includes('error'))) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CONTINUE_UNSUPPORTED */.qj.NODE_CONTINUE_UNSUPPORTED, at));
     switch(node.type){
         case 'trigger':
             {
@@ -2665,10 +2995,24 @@ function validateNodeConfig(node, flow, context, err, warn) {
                 else if (c.apiKey !== undefined && !(0,_flow_api_key_js__rspack_import_6/* .looksLikeApiKey */.Jb)(c.apiKey) && !(0,_flow_types_js__rspack_import_5/* .isStoredApiKey */.xA)(c.apiKey)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .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.
                 const path = (0,_flow_types_js__rspack_import_5/* .triggerPath */.um)(node);
+                const prefix = path ? `${path}: ` : '';
                 if (c.bodyType !== undefined && !_flow_types_js__rspack_import_5/* .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);
+                const declared = Array.isArray(c.inputSchema) ? c.inputSchema : [];
+                if (c.contract !== undefined && !_flow_types_js__rspack_import_5/* .FLOW_REQUEST_CONTRACTS.includes */.j_.includes(c.contract)) {
+                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.TRIGGER_CONTRACT_INVALID */.qj.TRIGGER_CONTRACT_INVALID, {
+                        ...at,
+                        contract: String(c.contract)
+                    }));
+                } else {
+                    // A declared field may not take the name of one the request type already brings.
+                    const reserved = new Set((0,_flow_types_js__rspack_import_5/* .contractFields */._h)(c.contract ?? 'custom').map((f)=>f.name));
+                    for (const field of declared)if (reserved.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_RESERVED */.qj.INPUT_NAME_RESERVED, {
+                        name: `${prefix}${field.name}`
+                    }));
+                }
+                validateInputFields(declared, prefix, 1, err);
                 break;
             }
         case 'validate':
@@ -2809,6 +3153,7 @@ function validateNodeConfig(node, flow, context, err, warn) {
         case 'entity_get':
             entity(c.entityCode);
             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 (c.fromRequest !== undefined && typeof c.fromRequest !== 'boolean') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_QUERY_FROM_REQUEST_INVALID */.qj.NODE_QUERY_FROM_REQUEST_INVALID, at));
             break;
         case 'entity_query':
             entity(c.entityCode);
@@ -2824,6 +3169,7 @@ function validateNodeConfig(node, flow, context, err, warn) {
                     max: _flow_types_js__rspack_import_5/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT
                 }));
             }
+            if (c.fromRequest !== undefined && typeof c.fromRequest !== 'boolean') err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_QUERY_FROM_REQUEST_INVALID */.qj.NODE_QUERY_FROM_REQUEST_INVALID, at));
             break;
         case 'call_flow':
             if (typeof c.flowSlug !== 'string' || !_flow_types_js__rspack_import_5/* .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));
@@ -2909,8 +3255,28 @@ function validateNodeConfig(node, flow, context, err, warn) {
             {
                 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_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_7/* .FLOW_SUBJECT_MESSAGES.THE_RESPONSE */.bc.THE_RESPONSE));
+                const format = c.format ?? 'raw';
+                if (!_flow_types_js__rspack_import_5/* .FLOW_RESPONSE_FORMATS.includes */.A4.includes(format)) {
+                    err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_RESPOND_FORMAT_INVALID */.qj.NODE_RESPOND_FORMAT_INVALID, {
+                        ...at,
+                        format: String(format)
+                    }));
+                    break;
+                }
+                const what = (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(format === 'raw' ? _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_RESPONSE */.bc.THE_RESPONSE : _config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_DATA */.bc.THE_DATA);
+                if (format !== 'message') {
+                    exprMap(c.body, KIND.response);
+                    if (c.bodyExpression !== undefined) expr(c.bodyExpression, what);
+                }
+                if (format === 'raw') break;
+                if (typeof c.message !== 'string' || !c.message.trim() || typeof c.messageKey !== 'string' || !c.messageKey.trim()) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_RESPOND_MESSAGE_REQUIRED */.qj.NODE_RESPOND_MESSAGE_REQUIRED, at));
+                exprMap(c.messageVariables, KIND.messageVariable);
+                if ((format === 'list' || format === 'bulk') && c.bodyExpression === undefined) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_RESPOND_LIST_VALUE_REQUIRED */.qj.NODE_RESPOND_LIST_VALUE_REQUIRED, at));
+                if (format === 'list' || format === 'bulk') optionalExpr(c.total, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_TOTAL */.bc.THE_TOTAL));
+                if (format === 'list') {
+                    optionalExpr(c.page, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_PAGE */.bc.THE_PAGE));
+                    optionalExpr(c.pageSize, (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_SUBJECT_MESSAGES.THE_PAGE_SIZE */.bc.THE_PAGE_SIZE));
+                }
                 break;
             }
         case 'commit':
@@ -2929,6 +3295,16 @@ function validateNodeConfig(node, flow, context, err, warn) {
                     max: _flow_types_js__rspack_import_5/* .FLOW_LIMITS.MAX_CODE_TIMEOUT_MS */.Or.MAX_CODE_TIMEOUT_MS
                 }));
             }
+            if (context.codeModules && typeof c.code === 'string') {
+                const allowed = context.codeModules;
+                for (const name of new Set(requiredPackages(c.code))){
+                    if (!allowed.includes(name)) err((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .FLOW_VALIDATION_MESSAGES.NODE_CODE_PACKAGE_NOT_ALLOWED */.qj.NODE_CODE_PACKAGE_NOT_ALLOWED, {
+                        ...at,
+                        package: name,
+                        allowed: allowed.join(', ') || '-'
+                    }));
+                }
+            }
             break;
     }
 }
@@ -3369,26 +3745,28 @@ __webpack_require__.d(__webpack_exports__, {
 },
 6390(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _flusys_nestjs_shared_utils__rspack_import_0 = __webpack_require__(9216);
-/* import */ var _config_message_keys_js__rspack_import_3 = __webpack_require__(5732);
-/* import */ var _enums_field_type_enum_js__rspack_import_2 = __webpack_require__(9614);
+/* import */ var _config_message_keys_js__rspack_import_4 = __webpack_require__(5732);
+/* import */ var _enums_field_type_enum_js__rspack_import_3 = __webpack_require__(9614);
 /* import */ var _services_field_value_validator_js__rspack_import_1 = __webpack_require__(3525);
+/* import */ var _flow_types_js__rspack_import_2 = __webpack_require__(6256);
+
 
 
 
 
 const TYPE_MAP = {
-    string: _enums_field_type_enum_js__rspack_import_2/* .FieldType.TEXT */.P.TEXT,
-    text: _enums_field_type_enum_js__rspack_import_2/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
-    number: _enums_field_type_enum_js__rspack_import_2/* .FieldType.DECIMAL */.P.DECIMAL,
-    integer: _enums_field_type_enum_js__rspack_import_2/* .FieldType.INTEGER */.P.INTEGER,
-    boolean: _enums_field_type_enum_js__rspack_import_2/* .FieldType.BOOLEAN */.P.BOOLEAN,
-    date: _enums_field_type_enum_js__rspack_import_2/* .FieldType.DATE */.P.DATE,
-    datetime: _enums_field_type_enum_js__rspack_import_2/* .FieldType.DATETIME */.P.DATETIME,
-    email: _enums_field_type_enum_js__rspack_import_2/* .FieldType.EMAIL */.P.EMAIL,
-    uuid: _enums_field_type_enum_js__rspack_import_2/* .FieldType.RELATION */.P.RELATION,
-    object: _enums_field_type_enum_js__rspack_import_2/* .FieldType.JSON */.P.JSON,
-    array: _enums_field_type_enum_js__rspack_import_2/* .FieldType.JSON */.P.JSON,
-    choice: _enums_field_type_enum_js__rspack_import_2/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT
+    string: _enums_field_type_enum_js__rspack_import_3/* .FieldType.TEXT */.P.TEXT,
+    text: _enums_field_type_enum_js__rspack_import_3/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
+    number: _enums_field_type_enum_js__rspack_import_3/* .FieldType.DECIMAL */.P.DECIMAL,
+    integer: _enums_field_type_enum_js__rspack_import_3/* .FieldType.INTEGER */.P.INTEGER,
+    boolean: _enums_field_type_enum_js__rspack_import_3/* .FieldType.BOOLEAN */.P.BOOLEAN,
+    date: _enums_field_type_enum_js__rspack_import_3/* .FieldType.DATE */.P.DATE,
+    datetime: _enums_field_type_enum_js__rspack_import_3/* .FieldType.DATETIME */.P.DATETIME,
+    email: _enums_field_type_enum_js__rspack_import_3/* .FieldType.EMAIL */.P.EMAIL,
+    uuid: _enums_field_type_enum_js__rspack_import_3/* .FieldType.RELATION */.P.RELATION,
+    object: _enums_field_type_enum_js__rspack_import_3/* .FieldType.JSON */.P.JSON,
+    array: _enums_field_type_enum_js__rspack_import_3/* .FieldType.JSON */.P.JSON,
+    choice: _enums_field_type_enum_js__rspack_import_3/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT
 };
 const isPlainObject = (v)=>typeof v === 'object' && v !== null && !Array.isArray(v);
 /**
@@ -3407,13 +3785,176 @@ const isPlainObject = (v)=>typeof v === 'object' && v !== null && !Array.isArray
     };
     return checkFields(schema, source, '');
 }
+const FIELD_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const OPEN_CONTRACTS = new Set([
+    'update',
+    'update_many'
+]);
+const QUERY_CONTRACTS = new Set([
+    'get_all',
+    'get_by_id',
+    'get_by_ids'
+]);
+/**
+ * Checks a request body against a Request step, the way its API controller endpoint's DTO would: a
+ * delete `id` sent as one id is read as a list and a get_by_ids `select` may be comma-separated; `sort`
+ * values must be ASC / DESC and `select` names plain field names. An update / update_many with no
+ * declared fields keeps the rest of the body, with only its `id` checked.
+ */ function validateEndpointInput(endpoint, body) {
+    const { contract } = endpoint;
+    const source = normalizeBody(contract, body);
+    const result = validateFlowInput(endpoint.inputSchema, source, endpoint.bodyType);
+    if (OPEN_CONTRACTS.has(contract) && endpoint.inputSchema.length === (0,_flow_types_js__rspack_import_2/* .contractFields */._h)(contract).length) result.values = keepRest(source, result.values);
+    if (QUERY_CONTRACTS.has(contract) && !Array.isArray(result.values)) result.errors.push(...contractErrors(result.values));
+    return result;
+}
+function normalizeBody(contract, body) {
+    if (!isPlainObject(body)) return body;
+    const source = body;
+    if (contract === 'delete' && typeof source['id'] === 'string') return {
+        ...source,
+        id: [
+            source['id']
+        ]
+    };
+    if (contract === 'get_by_ids' && typeof source['select'] === 'string') {
+        return {
+            ...source,
+            select: source['select'].split(',').map((name)=>name.trim()).filter(Boolean)
+        };
+    }
+    return body;
+}
+function keepRest(source, values) {
+    if (Array.isArray(values)) return values.map((item, i)=>isPlainObject(item) && Array.isArray(source) && isPlainObject(source[i]) ? {
+            ...source[i],
+            ...item
+        } : item);
+    return isPlainObject(source) ? {
+        ...source,
+        ...values
+    } : values;
+}
+function contractErrors(values) {
+    const errors = [];
+    if (isPlainObject(values['sort'])) errors.push(...sortErrors(values['sort']));
+    if (Array.isArray(values['select'])) errors.push(...selectErrors(values['select']));
+    return errors;
+}
+function sortErrors(sort) {
+    return Object.entries(sort).flatMap(([field, direction])=>!FIELD_NAME.test(field) || direction !== 'ASC' && direction !== 'DESC' ? [
+            {
+                field: `sort.${field}`,
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FLOW_MESSAGES.INPUT_SORT_INVALID */.wu.INPUT_SORT_INVALID, {
+                    field
+                })
+            }
+        ] : []);
+}
+function selectErrors(select) {
+    return select.flatMap((field, i)=>typeof field !== 'string' || !FIELD_NAME.test(field) ? [
+            {
+                field: `select[${i}]`,
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FLOW_MESSAGES.INPUT_SELECT_INVALID */.wu.INPUT_SELECT_INVALID, {
+                    field: String(field)
+                })
+            }
+        ] : []);
+}
+/** A whole number, from a number or numeric text; null for anything else. */ function wholeNumber(value) {
+    const n = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+    return typeof n === 'number' && Number.isInteger(n) ? n : null;
+}
+/**
+ * Reads `filter`, `sort`, `pagination`, `select` and `withDeleted` from a request body by the get_all
+ * contract's rules, whatever the Request step's type: `currentPage` a whole number of 0 or more (left
+ * out: 0), `pageSize` one from 1 to MAX_QUERY_LIMIT (left out: the step's own limit), numeric text
+ * accepted; `sort` ASC / DESC per plain field name; `select` plain field names. A list body has none.
+ */ function readRequestQuery(body) {
+    const query = {};
+    const errors = [];
+    if (!isPlainObject(body)) return {
+        query,
+        errors
+    };
+    const source = body;
+    const present = (key)=>source[key] !== undefined && source[key] !== null;
+    if (isPlainObject(source['filter'])) query.filter = source['filter'];
+    if (present('sort')) {
+        const sort = source['sort'];
+        const problems = isPlainObject(sort) ? sortErrors(sort) : [
+            {
+                field: 'sort',
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FLOW_MESSAGES.INPUT_SORT_INVALID */.wu.INPUT_SORT_INVALID, {
+                    field: 'sort'
+                })
+            }
+        ];
+        if (problems.length) errors.push(...problems);
+        else query.sort = sort;
+    }
+    if (present('pagination')) {
+        const pagination = source['pagination'];
+        if (!isPlainObject(pagination)) {
+            errors.push({
+                field: 'pagination',
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FIELD_VALIDATION_MESSAGES.MUST_BE_OBJECT */.KE.MUST_BE_OBJECT, {
+                    label: 'pagination'
+                })
+            });
+        } else {
+            const { currentPage: rawPage, pageSize: rawSize } = pagination;
+            const currentPage = rawPage === undefined || rawPage === null ? 0 : wholeNumber(rawPage);
+            const pageSize = rawSize === undefined || rawSize === null ? undefined : wholeNumber(rawSize);
+            if (currentPage === null || currentPage < 0) errors.push({
+                field: 'pagination.currentPage',
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FLOW_MESSAGES.INPUT_PAGE_INVALID */.wu.INPUT_PAGE_INVALID, {
+                    field: 'pagination.currentPage'
+                })
+            });
+            if (pageSize === null || pageSize !== undefined && (pageSize < 1 || pageSize > _flow_types_js__rspack_import_2/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT)) {
+                errors.push({
+                    field: 'pagination.pageSize',
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FLOW_MESSAGES.INPUT_PAGE_SIZE_INVALID */.wu.INPUT_PAGE_SIZE_INVALID, {
+                        field: 'pagination.pageSize',
+                        max: _flow_types_js__rspack_import_2/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT
+                    })
+                });
+            }
+            if (currentPage !== null && currentPage >= 0 && pageSize !== null) query.pagination = {
+                currentPage,
+                ...pageSize !== undefined ? {
+                    pageSize
+                } : {}
+            };
+        }
+    }
+    if (present('select')) {
+        const select = source['select'];
+        const problems = Array.isArray(select) ? selectErrors(select) : [
+            {
+                field: 'select',
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FLOW_MESSAGES.INPUT_SELECT_INVALID */.wu.INPUT_SELECT_INVALID, {
+                    field: 'select'
+                })
+            }
+        ];
+        if (problems.length) errors.push(...problems);
+        else query.select = select;
+    }
+    if (source['withDeleted'] === true) query.withDeleted = true;
+    return {
+        query,
+        errors
+    };
+}
 function checkList(schema, body) {
     if (!Array.isArray(body)) return {
         values: [],
         errors: [
             {
                 field: 'body',
-                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FLOW_MESSAGES.INPUT_BODY_NOT_LIST */.wu.INPUT_BODY_NOT_LIST)
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FLOW_MESSAGES.INPUT_BODY_NOT_LIST */.wu.INPUT_BODY_NOT_LIST)
             }
         ]
     };
@@ -3428,7 +3969,7 @@ function checkList(schema, body) {
             values.push(item);
             errors.push({
                 field: `[${i}]`,
-                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FLOW_MESSAGES.INPUT_BODY_ITEM_NOT_OBJECT */.wu.INPUT_BODY_ITEM_NOT_OBJECT, {
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FLOW_MESSAGES.INPUT_BODY_ITEM_NOT_OBJECT */.wu.INPUT_BODY_ITEM_NOT_OBJECT, {
                     index: i + 1
                 })
             });
@@ -3448,7 +3989,7 @@ function toValidatable(field, code, label) {
     return {
         code,
         label,
-        fieldType: TYPE_MAP[field.type] ?? _enums_field_type_enum_js__rspack_import_2/* .FieldType.TEXT */.P.TEXT,
+        fieldType: TYPE_MAP[field.type] ?? _enums_field_type_enum_js__rspack_import_3/* .FieldType.TEXT */.P.TEXT,
         nullable: !field.required,
         defaultValue: field.default ?? null,
         selectOptions: field.type === 'choice' ? field.options ?? [] : null,
@@ -3503,7 +4044,7 @@ function checkValue(field, supplied, raw, path, label) {
             errors: [
                 {
                     field: path,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MUST_BE_OBJECT */.KE.MUST_BE_OBJECT, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FIELD_VALIDATION_MESSAGES.MUST_BE_OBJECT */.KE.MUST_BE_OBJECT, {
                         label
                     })
                 }
@@ -3528,7 +4069,7 @@ function checkValue(field, supplied, raw, path, label) {
             errors: [
                 {
                     field: path,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MUST_BE_LIST */.KE.MUST_BE_LIST, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_4/* .FIELD_VALIDATION_MESSAGES.MUST_BE_LIST */.KE.MUST_BE_LIST, {
                         label
                     })
                 }
@@ -3561,7 +4102,8 @@ function checkValue(field, supplied, raw, path, label) {
 }
 
 __webpack_require__.d(__webpack_exports__, {
-  v: () => (validateFlowInput)
+  GP: () => (validateEndpointInput),
+  M2: () => (readRequestQuery)
 });
 
 
@@ -3662,9 +4204,17 @@ __webpack_require__.d(__webpack_exports__, {
 },
 2678(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 const SENSITIVE_KEY = /pass(word)?|secret|token|authorization|api[-_]?key|cookie|credential|private[-_]?key/i;
+const MAX_DEPTH = 8;
+const MAX_ITEMS = 100;
+const TWO_PASS = new Error('preview: needs the two-pass path');
+const BOXED = new Set([
+    '[object String]',
+    '[object Number]',
+    '[object Boolean]'
+]);
 /** 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));
+    if (depth > MAX_DEPTH) return '[deep]';
+    if (Array.isArray(value)) return value.slice(0, MAX_ITEMS).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') {
@@ -3676,13 +4226,43 @@ const SENSITIVE_KEY = /pass(word)?|secret|token|authorization|api[-_]?key|cookie
     }
     return value;
 }
+/**
+ * `JSON.stringify(redactSensitive(value))` in one pass, without building the redacted copy first: the same
+ * text for every value a flow step returns. Shapes one pass cannot write the same way (cycles, boxed
+ * primitives, a `toJSON` result with a `toJSON` of its own) throw, and the caller takes the two-pass path.
+ */ function redactedJson(value) {
+    const depths = new WeakMap();
+    return JSON.stringify(value, function(key, current) {
+        const holder = this;
+        const inArray = Array.isArray(holder);
+        if (!inArray && SENSITIVE_KEY.test(key)) return '***';
+        if (inArray && !(key in holder)) return undefined;
+        const original = holder[key];
+        const viaToJSON = original !== null && typeof original === 'object' && typeof original.toJSON === 'function';
+        if (viaToJSON && current !== null && typeof current === 'object' && typeof current.toJSON === 'function') throw TWO_PASS;
+        if (current !== null && typeof current === 'object' && BOXED.has(Object.prototype.toString.call(current))) throw TWO_PASS;
+        const depth = (depths.get(holder) ?? -1) + 1 + (viaToJSON ? 1 : 0);
+        if (depth > MAX_DEPTH) return '[deep]';
+        if (Array.isArray(current)) {
+            const items = current.length > MAX_ITEMS ? current.slice(0, MAX_ITEMS) : current;
+            depths.set(items, depth);
+            return items;
+        }
+        if (current !== null && typeof current === 'object') depths.set(current, depth);
+        return current;
+    });
+}
 /** Redacted, size-limited text for a trace/log entry. */ function preview(value, maxChars) {
     if (value === undefined) return '';
     let text;
     try {
-        text = JSON.stringify(redactSensitive(value)) ?? '';
+        text = redactedJson(value) ?? '';
     } catch  {
-        text = '[unserializable]';
+        try {
+            text = JSON.stringify(redactSensitive(value)) ?? '';
+        } catch  {
+            text = '[unserializable]';
+        }
     }
     return text.length > maxChars ? `${text.slice(0, maxChars)}... (${text.length} chars)` : text;
 }
@@ -3935,9 +4515,29 @@ class EntityBuilderConfigService {
     getConfig() {
         return this.options.config;
     }
+    isFastUpdatesEnabled() {
+        return this.getConfig()?.performance?.fastUpdates ?? true;
+    }
+    isPartialIndexesEnabled() {
+        return this.getConfig()?.performance?.partialIndexes ?? false;
+    }
     /** `designer.readOnly`, else the `ENTITY_BUILDER_READ_ONLY=true` env variable (production). */ isDesignerReadOnly() {
         return this.getConfig()?.designer?.readOnly ?? process.env['ENTITY_BUILDER_READ_ONLY'] === 'true';
     }
+    /** The packages a code step may `require`: `ENTITY_BUILDER_CODE_MODULES` (`dayjs,_=lodash`: a name, or name=specifier), overridden by `flows.code.modules`. */ getCodeModules() {
+        const fromEnv = (process.env['ENTITY_BUILDER_CODE_MODULES'] ?? '').split(',').map((entry)=>entry.trim()).filter(Boolean).map((entry)=>{
+            const [name, specifier] = entry.split('=').map((part)=>part.trim());
+            return [
+                name,
+                specifier || name
+            ];
+        });
+        const modules = {
+            ...Object.fromEntries(fromEnv),
+            ...this.getConfig()?.flows?.code?.modules
+        };
+        return Object.fromEntries(Object.entries(modules).filter((entry)=>!!entry[0] && typeof entry[1] === 'string' && !!entry[1].trim()));
+    }
     /** The values behind `${var:NAME}` in promoted flows: every non-empty `ENTITY_BUILDER_VAR_<NAME>` env variable, overridden by `bundles.variables`; names a placeholder cannot carry are left out. */ getBundleVariables() {
         const fromEnv = Object.entries(process.env).filter((entry)=>entry[0].startsWith(VARIABLE_ENV_PREFIX) && !!entry[1]).map(([key, value])=>[
                 key.slice(VARIABLE_ENV_PREFIX.length),
@@ -4054,23 +4654,54 @@ class EntityBuilderDataSourceProvider extends _flusys_nestjs_shared_modules__rsp
    * just by instance identity, so a fresh schema instance with the same name still
    * resolves correctly after a rebuild.
    */ async registerDynamicSchema(schema) {
+        await this.registerDynamicSchemas([
+            schema
+        ]);
+    }
+    /**
+   * Several schemas with ONE metadata rebuild - each rebuild reads every entity of the DataSource, so
+   * registering N entities one by one costs N full rebuilds. A failed rebuild puts `options.entities`
+   * back as it was and rebuilds it, so one bad schema never breaks later registrations.
+   */ async registerDynamicSchemas(schemas) {
         const dataSource = await this.getDataSource();
         const perDsMap = this.statics.registeredSchemas.get(dataSource) ?? new Map();
         this.statics.registeredSchemas.set(dataSource, perDsMap);
-        if (perDsMap.get(schema.options.name) === schema) return;
+        if (schemas.every((schema)=>perDsMap.get(schema.options.name) === schema)) return;
         // Serialize concurrent registrations against the SAME DataSource - buildMetadatas()
         // does a full rebuild from `options.entities`, so two racing pushes must not interleave.
         const prior = this.statics.rebuildLocks.get(dataSource) ?? Promise.resolve();
         const next = prior.then(async ()=>{
-            perDsMap.set(schema.options.name, schema);
+            const pending = schemas.filter((schema)=>perDsMap.get(schema.options.name) !== schema);
+            if (!pending.length) return;
             const entitiesArr = dataSource.options.entities;
-            const idx = entitiesArr.findIndex((e)=>e instanceof Object && e.options?.name === schema.options.name);
-            if (idx >= 0) entitiesArr[idx] = schema;
-            else entitiesArr.push(schema);
+            const before = [
+                ...entitiesArr
+            ];
+            const replaced = new Map(pending.map((schema)=>[
+                    schema.options.name,
+                    perDsMap.get(schema.options.name)
+                ]));
+            for (const schema of pending){
+                perDsMap.set(schema.options.name, schema);
+                const idx = entitiesArr.findIndex((e)=>e instanceof Object && e.options?.name === schema.options.name);
+                if (idx >= 0) entitiesArr[idx] = schema;
+                else entitiesArr.push(schema);
+            }
             // buildMetadatas() is `protected` in TypeORM's public .d.ts (a compile-time-only
             // restriction, not enforced by the JS runtime) but is the only way to rebuild
             // entityMetadatas from options.entities after DataSource.initialize() has run.
-            await dataSource.buildMetadatas();
+            const rebuild = ()=>dataSource.buildMetadatas();
+            try {
+                await rebuild();
+            } catch (error) {
+                entitiesArr.splice(0, entitiesArr.length, ...before);
+                for (const [name, previous] of replaced){
+                    if (previous) perDsMap.set(name, previous);
+                    else perDsMap.delete(name);
+                }
+                await rebuild().catch(()=>undefined);
+                throw error;
+            }
         });
         this.statics.rebuildLocks.set(dataSource, next.catch(()=>undefined));
         await next;
@@ -4107,11 +4738,22 @@ __webpack_require__.d(__webpack_exports__, {
 },
 3525(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _flusys_nestjs_shared_utils__rspack_import_0 = __webpack_require__(9216);
-/* import */ var _config_message_keys_js__rspack_import_2 = __webpack_require__(5732);
-/* import */ var _enums_field_type_enum_js__rspack_import_1 = __webpack_require__(9614);
+/* import */ var _config_message_keys_js__rspack_import_3 = __webpack_require__(5732);
+/* import */ var _enums_field_type_enum_js__rspack_import_2 = __webpack_require__(9614);
+/* import */ var _rule_engine_rule_values_js__rspack_import_1 = __webpack_require__(6622);
+
 
 
 
+/** A field's value rules alone, optional and without a default: checks one value (a default, a backfill) as a record field would. */ const valueRulesOf = (field)=>({
+        code: field.code,
+        label: field.label ?? field.code,
+        fieldType: field.fieldType,
+        nullable: true,
+        defaultValue: null,
+        selectOptions: field.selectOptions ?? null,
+        validationRules: field.validationRules ?? null
+    });
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 const DATE = /^\d{4}-\d{2}-\d{2}$/;
@@ -4143,18 +4785,18 @@ function isEmpty(value) {
             })
         });
     switch(field.fieldType){
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.TEXT */.P.TEXT:
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL:
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.TEXT */.P.TEXT:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.EMAIL */.P.EMAIL:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT:
             {
-                if (typeof value !== 'string') return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MUST_BE_TEXT */.KE.MUST_BE_TEXT);
-                if (value.length > TEXT_MAX) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MAX_LENGTH */.KE.MAX_LENGTH, {
+                if (typeof value !== 'string') return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MUST_BE_TEXT */.KE.MUST_BE_TEXT);
+                if (value.length > TEXT_MAX) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MAX_LENGTH */.KE.MAX_LENGTH, {
                     max: TEXT_MAX
                 });
-                if (field.fieldType === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL && !EMAIL.test(value)) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.INVALID_EMAIL */.KE.INVALID_EMAIL);
-                if (field.fieldType === _enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT) {
+                if (field.fieldType === _enums_field_type_enum_js__rspack_import_2/* .FieldType.EMAIL */.P.EMAIL && !EMAIL.test(value)) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.INVALID_EMAIL */.KE.INVALID_EMAIL);
+                if (field.fieldType === _enums_field_type_enum_js__rspack_import_2/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT) {
                     const options = optionValues(field);
-                    if (options && !options.includes(value)) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.ONE_OF */.KE.ONE_OF, {
+                    if (options && !options.includes(value)) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.ONE_OF */.KE.ONE_OF, {
                         options: options.join(', ')
                     });
                 }
@@ -4162,19 +4804,19 @@ function isEmpty(value) {
                     value
                 };
             }
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.LONG_TEXT */.P.LONG_TEXT:
-            if (typeof value !== 'string') return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MUST_BE_TEXT */.KE.MUST_BE_TEXT);
-            if (value.length > LONG_TEXT_MAX) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MAX_LENGTH */.KE.MAX_LENGTH, {
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.LONG_TEXT */.P.LONG_TEXT:
+            if (typeof value !== 'string') return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MUST_BE_TEXT */.KE.MUST_BE_TEXT);
+            if (value.length > LONG_TEXT_MAX) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MAX_LENGTH */.KE.MAX_LENGTH, {
                 max: LONG_TEXT_MAX
             });
             return {
                 value
             };
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.INTEGER */.P.INTEGER:
             {
                 const n = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
-                if (typeof n !== 'number' || !Number.isInteger(n)) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.WHOLE_NUMBER */.KE.WHOLE_NUMBER);
-                if (n < INT_MIN || n > INT_MAX) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.NUMBER_BETWEEN */.KE.NUMBER_BETWEEN, {
+                if (typeof n !== 'number' || !Number.isInteger(n)) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.WHOLE_NUMBER */.KE.WHOLE_NUMBER);
+                if (n < INT_MIN || n > INT_MAX) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.NUMBER_BETWEEN */.KE.NUMBER_BETWEEN, {
                     min: INT_MIN,
                     max: INT_MAX
                 });
@@ -4182,16 +4824,16 @@ function isEmpty(value) {
                     value: n
                 };
             }
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.DECIMAL */.P.DECIMAL:
             {
                 const n = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
-                if (typeof n !== 'number' || !Number.isFinite(n)) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.NUMBER */.KE.NUMBER);
-                if (Math.abs(n) >= DECIMAL_LIMIT) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.NUMBER_TOO_LARGE */.KE.NUMBER_TOO_LARGE);
+                if (typeof n !== 'number' || !Number.isFinite(n)) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.NUMBER */.KE.NUMBER);
+                if (Math.abs(n) >= DECIMAL_LIMIT) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.NUMBER_TOO_LARGE */.KE.NUMBER_TOO_LARGE);
                 return {
                     value: n
                 };
             }
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.BOOLEAN */.P.BOOLEAN:
             {
                 if (typeof value === 'boolean') return {
                     value
@@ -4202,46 +4844,47 @@ function isEmpty(value) {
                 if (value === 'false') return {
                     value: false
                 };
-                return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.BOOLEAN */.KE.BOOLEAN);
+                return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.BOOLEAN */.KE.BOOLEAN);
             }
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATE */.P.DATE:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.DATE */.P.DATE:
             if (typeof value !== 'string' || !DATE.test(value) || !isRealCalendarDate(value)) {
-                return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.REAL_DATE */.KE.REAL_DATE);
+                return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.REAL_DATE */.KE.REAL_DATE);
             }
             return {
                 value
             };
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATETIME */.P.DATETIME:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.DATETIME */.P.DATETIME:
             {
-                const parsed = typeof value === 'string' || value instanceof Date ? new Date(value) : null;
-                if (!parsed || Number.isNaN(parsed.getTime())) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.ISO_DATETIME */.KE.ISO_DATETIME);
+                // Zone-less ISO text is UTC, never the server's local time.
+                const time = value instanceof Date ? value.getTime() : typeof value === 'string' ? (0,_rule_engine_rule_values_js__rspack_import_1/* .parseDateText */.hz)(value) : Number.NaN;
+                if (!Number.isFinite(time)) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.ISO_DATETIME */.KE.ISO_DATETIME);
                 return {
-                    value: parsed.toISOString()
+                    value: new Date(time).toISOString()
                 };
             }
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT:
             {
-                if (!Array.isArray(value) || value.some((v)=>typeof v !== 'string')) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.TEXT_LIST */.KE.TEXT_LIST);
+                if (!Array.isArray(value) || value.some((v)=>typeof v !== 'string')) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.TEXT_LIST */.KE.TEXT_LIST);
                 const options = optionValues(field);
                 const invalid = options ? value.filter((v)=>!options.includes(v)) : [];
-                if (invalid.length) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.UNKNOWN_OPTIONS */.KE.UNKNOWN_OPTIONS, {
+                if (invalid.length) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.UNKNOWN_OPTIONS */.KE.UNKNOWN_OPTIONS, {
                     options: invalid.join(', ')
                 });
                 return {
                     value
                 };
             }
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.RELATION */.P.RELATION:
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.FILE */.P.FILE:
-            if (typeof value !== 'string' || !UUID.test(value)) return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.UUID */.KE.UUID);
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.RELATION */.P.RELATION:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.FILE */.P.FILE:
+            if (typeof value !== 'string' || !UUID.test(value)) return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.UUID */.KE.UUID);
             return {
                 value
             };
-        case _enums_field_type_enum_js__rspack_import_1/* .FieldType.JSON */.P.JSON:
+        case _enums_field_type_enum_js__rspack_import_2/* .FieldType.JSON */.P.JSON:
             try {
                 JSON.stringify(value);
             } catch  {
-                return fail(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.JSON */.KE.JSON);
+                return fail(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.JSON */.KE.JSON);
             }
             return {
                 value
@@ -4256,38 +4899,38 @@ function checkRules(field, value) {
     const rules = field.validationRules;
     if (!rules) return null;
     const label = field.label;
-    const numeric = field.fieldType === _enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER || field.fieldType === _enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL;
+    const numeric = field.fieldType === _enums_field_type_enum_js__rspack_import_2/* .FieldType.INTEGER */.P.INTEGER || field.fieldType === _enums_field_type_enum_js__rspack_import_2/* .FieldType.DECIMAL */.P.DECIMAL;
     const text = typeof value === 'string';
     if (numeric && typeof value === 'number') {
-        if (typeof rules.min === 'number' && value < rules.min) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MIN_VALUE */.KE.MIN_VALUE, {
+        if (typeof rules.min === 'number' && value < rules.min) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MIN_VALUE */.KE.MIN_VALUE, {
             label,
             min: rules.min
         });
-        if (typeof rules.max === 'number' && value > rules.max) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MAX_VALUE */.KE.MAX_VALUE, {
+        if (typeof rules.max === 'number' && value > rules.max) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MAX_VALUE */.KE.MAX_VALUE, {
             label,
             max: rules.max
         });
     }
     if (text) {
         if (typeof rules.minLength === 'number' && value.length < rules.minLength) {
-            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MIN_LENGTH */.KE.MIN_LENGTH, {
+            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MIN_LENGTH */.KE.MIN_LENGTH, {
                 label,
                 min: rules.minLength
             });
         }
         if (typeof rules.maxLength === 'number' && value.length > rules.maxLength) {
-            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MAX_LENGTH */.KE.MAX_LENGTH, {
+            return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MAX_LENGTH */.KE.MAX_LENGTH, {
                 label,
                 max: rules.maxLength
             });
         }
     }
     if (Array.isArray(value)) {
-        if (typeof rules.minItems === 'number' && value.length < rules.minItems) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MIN_ITEMS */.KE.MIN_ITEMS, {
+        if (typeof rules.minItems === 'number' && value.length < rules.minItems) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MIN_ITEMS */.KE.MIN_ITEMS, {
             label,
             min: rules.minItems
         });
-        if (typeof rules.maxItems === 'number' && value.length > rules.maxItems) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.MAX_ITEMS */.KE.MAX_ITEMS, {
+        if (typeof rules.maxItems === 'number' && value.length > rules.maxItems) return (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.MAX_ITEMS */.KE.MAX_ITEMS, {
             label,
             max: rules.maxItems
         });
@@ -4317,7 +4960,7 @@ function checkRules(field, value) {
         if (isEmpty(raw)) {
             if (!field.nullable) errors.push({
                 field: field.code,
-                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .FIELD_VALIDATION_MESSAGES.REQUIRED */.KE.REQUIRED, {
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_3/* .FIELD_VALIDATION_MESSAGES.REQUIRED */.KE.REQUIRED, {
                     label: field.label
                 })
             });
@@ -4350,6 +4993,8 @@ function checkRules(field, value) {
 
 __webpack_require__.d(__webpack_exports__, {
   e: () => (validateRecord)
+}, {
+  C: valueRulesOf
 });
 
 
@@ -4361,17 +5006,19 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _flusys_nestjs_shared_modules__rspack_import_3 = __webpack_require__(1236);
 /* import */ var _nestjs_common__rspack_import_4 = __webpack_require__(6157);
 /* import */ var typeorm__rspack_import_5 = __webpack_require__(7158);
-/* import */ var _config_event_actions_js__rspack_import_16 = __webpack_require__(982);
-/* import */ var _config_message_keys_js__rspack_import_14 = __webpack_require__(5732);
+/* import */ var _config_event_actions_js__rspack_import_18 = __webpack_require__(982);
+/* import */ var _config_message_keys_js__rspack_import_16 = __webpack_require__(5732);
 /* import */ var _entities_entity_definition_entity_js__rspack_import_6 = __webpack_require__(3189);
 /* import */ var _entities_flow_definition_entity_js__rspack_import_7 = __webpack_require__(3770);
-/* import */ var _entities_flow_version_entity_js__rspack_import_8 = __webpack_require__(2399);
-/* import */ var _flow_engine_flow_api_key_js__rspack_import_9 = __webpack_require__(4816);
-/* import */ var _flow_engine_flow_permission_logic_js__rspack_import_13 = __webpack_require__(8220);
-/* import */ var _flow_engine_flow_graph_validator_js__rspack_import_10 = __webpack_require__(3186);
-/* import */ var _flow_engine_flow_types_js__rspack_import_11 = __webpack_require__(6256);
-/* import */ var _interfaces_flow_definition_interface_js__rspack_import_15 = __webpack_require__(9609);
-/* import */ var _entity_builder_datasource_provider_js__rspack_import_12 = __webpack_require__(424);
+/* import */ var _entities_flow_execution_entity_js__rspack_import_8 = __webpack_require__(9641);
+/* import */ var _entities_flow_version_entity_js__rspack_import_9 = __webpack_require__(2399);
+/* import */ var _flow_engine_flow_api_key_js__rspack_import_10 = __webpack_require__(4816);
+/* import */ var _flow_engine_flow_permission_logic_js__rspack_import_15 = __webpack_require__(8220);
+/* import */ var _flow_engine_flow_graph_validator_js__rspack_import_11 = __webpack_require__(3186);
+/* import */ var _flow_engine_flow_types_js__rspack_import_12 = __webpack_require__(6256);
+/* import */ var _interfaces_flow_definition_interface_js__rspack_import_17 = __webpack_require__(9609);
+/* import */ var _entity_builder_config_service_js__rspack_import_13 = __webpack_require__(4281);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_14 = __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") {
@@ -4412,15 +5059,19 @@ function _ts_param(paramIndex, decorator) {
 
 
 
+
+
 const defaultFlowPermissionCode = (slug)=>`entity_builder.flow.${slug}.execute`;
-/** The rule a `permission` URL asks callers to pass: its own, or the flow's execute permission. */ const flowPermissions = (endpoint, slug)=>endpoint.permissions ?? (0,_flow_engine_flow_permission_logic_js__rspack_import_13/* .permissionAction */.s)(defaultFlowPermissionCode(slug));
+/** The rule a `permission` URL asks callers to pass: its own, or the flow's execute permission. */ const flowPermissions = (endpoint, slug)=>endpoint.permissions ?? (0,_flow_engine_flow_permission_logic_js__rspack_import_15/* .permissionAction */.s)(defaultFlowPermissionCode(slug));
+/** A `permission` URL without a rule of its own: it asks for the flow's execute permission, which publishing registers. */ const asksExecutePermission = (endpoint)=>endpoint.authMode === 'permission' && !endpoint.permissions;
+const logger = new _nestjs_common__rspack_import_4.Logger('FlowDefinitionService');
 const flowNotFound = ()=>new _nestjs_common__rspack_import_4.NotFoundException({
         message: 'Flow not found.',
-        messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.NOT_FOUND */.wu.NOT_FOUND
+        messageKey: _config_message_keys_js__rspack_import_16/* .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(_interfaces_flow_definition_interface_js__rspack_import_15/* .FLOW_VERSIONED_FIELDS.filter */.v.filter((key)=>source[key] !== undefined).map((key)=>[
+    return Object.fromEntries(_interfaces_flow_definition_interface_js__rspack_import_17/* .FLOW_VERSIONED_FIELDS.filter */.v.filter((key)=>source[key] !== undefined).map((key)=>[
             key,
             source[key]
         ]));
@@ -4446,8 +5097,9 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
     notifications;
     email;
     companyAccess;
-    constructor(cacheManager, utilsService, provider, permissionCache, actionRegistry, notifications, email, companyAccess){
-        super(_config_event_actions_js__rspack_import_16/* .ENTITY_BUILDER_EVENT_ENTITIES.FLOW_DEFINITION */.P.FLOW_DEFINITION, cacheManager, utilsService, FlowDefinitionService.name, true, _config_event_actions_js__rspack_import_16/* .ENTITY_BUILDER_EVENT_MODULE */.S, provider, _entities_flow_definition_entity_js__rspack_import_7/* .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;
+    config;
+    constructor(cacheManager, utilsService, provider, permissionCache, actionRegistry, notifications, email, companyAccess, config){
+        super(_config_event_actions_js__rspack_import_18/* .ENTITY_BUILDER_EVENT_ENTITIES.FLOW_DEFINITION */.P.FLOW_DEFINITION, cacheManager, utilsService, FlowDefinitionService.name, true, _config_event_actions_js__rspack_import_18/* .ENTITY_BUILDER_EVENT_MODULE */.S, provider, _entities_flow_definition_entity_js__rspack_import_7/* .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, this.config = config;
     }
     async findOrFail(id) {
         const flow = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G)).findOne({
@@ -4465,7 +5117,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
             }
         });
         const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G)).find();
-        return (0,_flow_engine_flow_graph_validator_js__rspack_import_10/* .validateFlow */.nC)(settings, {
+        return (0,_flow_engine_flow_graph_validator_js__rspack_import_11/* .validateFlow */.nC)(settings, {
             knownEntityCodes: new Set(entities.map((e)=>e.code)),
             knownFlows: new Map(flows.map((flow)=>[
                     flow.slug,
@@ -4475,9 +5127,13 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
                 notification: !!this.notifications,
                 email: !!this.email
             },
-            companyMembers: !!this.companyAccess
+            companyMembers: !!this.companyAccess,
+            codeModules: this.config ? this.codePackages() : undefined
         });
     }
+    /** The names a code step may `require`, as the app configured them. */ codePackages() {
+        return Object.keys(this.config?.getCodeModules() ?? {});
+    }
     /** Names of the other flows whose `call_flow` nodes run `slug`. */ async callersOf(slug, excludeIds) {
         const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G)).find({
             select: {
@@ -4493,7 +5149,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         if (!callers.length) return;
         throw new _nestjs_common__rspack_import_4.ConflictException({
             message: `The flow '${slug}' is called by: ${callers.join(', ')}. Change those flows first.`,
-            messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.CALLED_BY_OTHER_FLOWS */.wu.CALLED_BY_OTHER_FLOWS,
+            messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.CALLED_BY_OTHER_FLOWS */.wu.CALLED_BY_OTHER_FLOWS,
             messageVariables: {
                 slug,
                 flows: callers.join(', ')
@@ -4532,11 +5188,11 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
             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_engine_flow_graph_validator_js__rspack_import_10/* .callProblems */.r7)(settings, before.slug, now)){
+            for (const problem of (0,_flow_engine_flow_graph_validator_js__rspack_import_11/* .callProblems */.r7)(settings, before.slug, now)){
                 const key = JSON.stringify(problem);
                 existing.set(key, (existing.get(key) ?? 0) + 1);
             }
-            const added = (0,_flow_engine_flow_graph_validator_js__rspack_import_10/* .callProblems */.r7)(settings, before.slug, next).filter((problem)=>{
+            const added = (0,_flow_engine_flow_graph_validator_js__rspack_import_11/* .callProblems */.r7)(settings, before.slug, next).filter((problem)=>{
                 const key = JSON.stringify(problem);
                 const left = existing.get(key) ?? 0;
                 existing.set(key, left - 1);
@@ -4551,7 +5207,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         const names = broken.map((b)=>b.flow).join(', ');
         throw new _nestjs_common__rspack_import_4.ConflictException({
             message: `This change breaks flows that call '${before.slug}': ${names}. Change those flows first.`,
-            messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.CALLERS_BROKEN */.wu.CALLERS_BROKEN,
+            messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.CALLERS_BROKEN */.wu.CALLERS_BROKEN,
             messageVariables: {
                 slug: before.slug,
                 flows: names
@@ -4564,8 +5220,8 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         });
     }
     /** 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_engine_flow_types_js__rspack_import_11/* .flowEndpoints */.Xr)(after).map((e)=>e.path));
-        const removed = (0,_flow_engine_flow_types_js__rspack_import_11/* .flowEndpoints */.Xr)(before).map((e)=>e.path).filter((path)=>!kept.has(path));
+        const kept = new Set((0,_flow_engine_flow_types_js__rspack_import_12/* .flowEndpoints */.Xr)(after).map((e)=>e.path));
+        const removed = (0,_flow_engine_flow_types_js__rspack_import_12/* .flowEndpoints */.Xr)(before).map((e)=>e.path).filter((path)=>!kept.has(path));
         if (!removed.length) return;
         const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G)).find({
             select: {
@@ -4580,7 +5236,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
             const url = `api-flows/${before.slug}${path ? `/${path}` : ''}`;
             throw new _nestjs_common__rspack_import_4.ConflictException({
                 message: `The URL ${url} is called by: ${callers.join(', ')}. Change those flows first.`,
-                messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.ENDPOINT_CALLED_BY_OTHER_FLOWS */.wu.ENDPOINT_CALLED_BY_OTHER_FLOWS,
+                messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.ENDPOINT_CALLED_BY_OTHER_FLOWS */.wu.ENDPOINT_CALLED_BY_OTHER_FLOWS,
                 messageVariables: {
                     url,
                     flows: callers.join(', ')
@@ -4593,7 +5249,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         if (errors.length) {
             throw new _nestjs_common__rspack_import_4.BadRequestException({
                 message: 'The flow has problems.',
-                messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.INVALID */.wu.INVALID,
+                messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.INVALID */.wu.INVALID,
                 errors: errors.map((error)=>({
                         field: 'flow',
                         ...error
@@ -4604,13 +5260,12 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         const clash = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G)).findOne({
             where: {
                 slug: settings.slug
-            },
-            withDeleted: true
+            }
         });
         if (clash && clash.id !== selfId) {
             throw new _nestjs_common__rspack_import_4.ConflictException({
                 message: `The URL name '${settings.slug}' is already used by another flow.`,
-                messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.SLUG_TAKEN */.wu.SLUG_TAKEN,
+                messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.SLUG_TAKEN */.wu.SLUG_TAKEN,
                 messageVariables: {
                     slug: settings.slug
                 }
@@ -4642,7 +5297,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
             dto
         ]){
             await this.assertSaveable(toFlowSettings(d), user);
-            d.nodes = (0,_flow_engine_flow_api_key_js__rspack_import_9/* .sealApiKeys */.ue)(d.nodes);
+            d.nodes = (0,_flow_engine_flow_api_key_js__rspack_import_10/* .sealApiKeys */.ue)(d.nodes);
             d.version = 0;
         }
     }
@@ -4663,7 +5318,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
                 isActive: d.isActive ?? existing.isActive,
                 version: existing.version
             });
-            if (d.nodes) d.nodes = (0,_flow_engine_flow_api_key_js__rspack_import_9/* .sealApiKeys */.ue)(d.nodes);
+            if (d.nodes) d.nodes = (0,_flow_engine_flow_api_key_js__rspack_import_10/* .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) {
@@ -4687,7 +5342,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         const published = isPublished(existing);
         if (published && !existing.draft) throw new _nestjs_common__rspack_import_4.BadRequestException({
             message: 'There are no changes to publish.',
-            messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.NOTHING_TO_PUBLISH */.wu.NOTHING_TO_PUBLISH
+            messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.NOTHING_TO_PUBLISH */.wu.NOTHING_TO_PUBLISH
         });
         const next = workingCopy(existing);
         const settings = toFlowSettings(next);
@@ -4700,7 +5355,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         try {
             await qr.connect();
             await qr.startTransaction();
-            const versions = qr.manager.getRepository(_entities_flow_version_entity_js__rspack_import_8/* .FlowVersion */.p);
+            const versions = qr.manager.getRepository(_entities_flow_version_entity_js__rspack_import_9/* .FlowVersion */.p);
             Object.assign(existing, next, {
                 draft: null,
                 version: existing.version + 1,
@@ -4722,7 +5377,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         } finally{
             await qr.release().catch(()=>undefined);
         }
-        await this.clearCaches(existing);
+        await this.invalidateCache();
         await this.provisionPermissions([
             existing
         ]);
@@ -4730,7 +5385,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
     }
     /** Newest first, without the definitions (`getVersion` returns one in full). */ async listVersions(flowId) {
         await this.findOrFail(flowId);
-        return (await this.provider.getRepository(_entities_flow_version_entity_js__rspack_import_8/* .FlowVersion */.p)).find({
+        return (await this.provider.getRepository(_entities_flow_version_entity_js__rspack_import_9/* .FlowVersion */.p)).find({
             where: {
                 flowId
             },
@@ -4748,7 +5403,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         });
     }
     async getVersion(flowId, version) {
-        const row = await (await this.provider.getRepository(_entities_flow_version_entity_js__rspack_import_8/* .FlowVersion */.p)).findOne({
+        const row = await (await this.provider.getRepository(_entities_flow_version_entity_js__rspack_import_9/* .FlowVersion */.p)).findOne({
             where: {
                 flowId,
                 version
@@ -4756,7 +5411,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         });
         if (!row) throw new _nestjs_common__rspack_import_4.NotFoundException({
             message: `Version ${version} of this flow was not found.`,
-            messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.VERSION_NOT_FOUND */.wu.VERSION_NOT_FOUND,
+            messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.VERSION_NOT_FOUND */.wu.VERSION_NOT_FOUND,
             messageVariables: {
                 version
             }
@@ -4778,7 +5433,7 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
         const flow = await this.findOrFail(flowId);
         if (!flow.draft) throw new _nestjs_common__rspack_import_4.BadRequestException({
             message: 'This flow has no unpublished changes.',
-            messageKey: _config_message_keys_js__rspack_import_14/* .FLOW_MESSAGES.NO_DRAFT */.wu.NO_DRAFT
+            messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.NO_DRAFT */.wu.NO_DRAFT
         });
         flow.draft = null;
         return this.saveDraft(flow, user);
@@ -4788,38 +5443,70 @@ class FlowDefinitionService extends _flusys_nestjs_shared_classes__rspack_import
             draft: flow.draft,
             updatedById: user?.id ?? null
         });
-        await this.clearCaches(flow);
+        await this.invalidateCache();
         return flow;
     }
-    async clearCaches(flow) {
-        if (!this.isCacheable) return;
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                flow
-            ])
-        ]);
+    async delete(option, user) {
+        if (option.type === 'restore') {
+            throw new _nestjs_common__rspack_import_4.BadRequestException({
+                message: 'A deleted flow is removed for good and cannot be restored.',
+                messageKey: _config_message_keys_js__rspack_import_16/* .FLOW_MESSAGES.RESTORE_UNSUPPORTED */.wu.RESTORE_UNSUPPORTED
+            });
+        }
+        const ids = Array.isArray(option.id) ? option.id : [
+            option.id
+        ];
+        const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G)).find({
+            select: {
+                id: true,
+                slug: true
+            },
+            where: {
+                id: (0,typeorm__rspack_import_5.In)(ids)
+            }
+        });
+        await super.delete({
+            ...option,
+            type: 'permanent'
+        }, user);
+        await this.deprovisionPermissions(flows);
+        return null;
     }
-    async beforeDeleteOperation(dto, user, _qr) {
+    async beforeDeleteOperation(dto, _user, _qr) {
         const ids = Array.isArray(dto.id) ? dto.id : [
             dto.id
         ];
         const flows = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G)).find({
             where: {
                 id: (0,typeorm__rspack_import_5.In)(ids)
-            },
-            withDeleted: true
+            }
         });
         if (flows.length !== ids.length) throw flowNotFound();
-        if (dto.type === 'restore') return;
         for (const flow of flows)await this.assertNotCalled(flow.slug, ids);
     }
+    async afterDeleteOperation(deleted, _dto, _user, qr) {
+        const flowId = (0,typeorm__rspack_import_5.In)(deleted.map((flow)=>flow.id));
+        await qr.manager.getRepository(_entities_flow_version_entity_js__rspack_import_9/* .FlowVersion */.p).delete({
+            flowId
+        });
+        await qr.manager.getRepository(_entities_flow_execution_entity_js__rspack_import_8/* .FlowExecution */.j).delete({
+            flowId
+        });
+    }
+    /** After the commit: a failure leaves an unused action behind, never a flow that is half deleted. */ async deprovisionPermissions(flows) {
+        if (!this.actionRegistry || !flows.length) return;
+        try {
+            await this.actionRegistry.removeActionsByCodes(flows.map((flow)=>defaultFlowPermissionCode(flow.slug)));
+        } catch (error) {
+            logger.warn(`The execute permissions of deleted flows could not be removed: ${error.message}`);
+        }
+    }
     /** The flow's execute permission, registered so it can be granted, when a published URL asks for it (a URL with its own rule names existing permissions). */ async provisionPermissions(flows) {
         if (!this.actionRegistry) return;
         const actions = new Map();
         for (const flow of flows){
-            for (const endpoint of (0,_flow_engine_flow_types_js__rspack_import_11/* .flowEndpoints */.Xr)(flow)){
-                if (endpoint.authMode !== 'permission' || endpoint.permissions) continue;
+            for (const endpoint of (0,_flow_engine_flow_types_js__rspack_import_12/* .flowEndpoints */.Xr)(flow)){
+                if (!asksExecutePermission(endpoint)) continue;
                 const code = defaultFlowPermissionCode(flow.slug);
                 if (!actions.has(code)) actions.set(code, endpoint.path ? `Run ${flow.name} (${endpoint.path})` : `Run ${flow.name}`);
             }
@@ -4838,7 +5525,7 @@ FlowDefinitionService = _ts_decorate([
     }),
     _ts_param(0, (0,_nestjs_common__rspack_import_4.Inject)('CACHE_INSTANCE')),
     _ts_param(1, (0,_nestjs_common__rspack_import_4.Inject)(_flusys_nestjs_shared_modules__rspack_import_3.UtilsService)),
-    _ts_param(2, (0,_nestjs_common__rspack_import_4.Inject)(_entity_builder_datasource_provider_js__rspack_import_12/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_4.Inject)(_entity_builder_datasource_provider_js__rspack_import_14/* .EntityBuilderDataSourceProvider */.D)),
     _ts_param(3, (0,_nestjs_common__rspack_import_4.Inject)(_flusys_nestjs_shared_modules__rspack_import_3.SharedPermissionCacheService)),
     _ts_param(4, (0,_nestjs_common__rspack_import_4.Optional)()),
     _ts_param(4, (0,_nestjs_common__rspack_import_4.Inject)(_flusys_nestjs_shared__rspack_import_0.PERMISSION_ACTION_REGISTRY)),
@@ -4848,16 +5535,19 @@ FlowDefinitionService = _ts_decorate([
     _ts_param(6, (0,_nestjs_common__rspack_import_4.Inject)(_flusys_nestjs_shared_interfaces__rspack_import_2.EMAIL_ADAPTER)),
     _ts_param(7, (0,_nestjs_common__rspack_import_4.Optional)()),
     _ts_param(7, (0,_nestjs_common__rspack_import_4.Inject)(_flusys_nestjs_shared_interfaces__rspack_import_2.COMPANY_ACCESS_RESOLVER)),
+    _ts_param(8, (0,_nestjs_common__rspack_import_4.Optional)()),
+    _ts_param(8, (0,_nestjs_common__rspack_import_4.Inject)(_entity_builder_config_service_js__rspack_import_13/* .EntityBuilderConfigService */.E)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         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_3.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_3.UtilsService,
-        typeof _entity_builder_datasource_provider_js__rspack_import_12/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_12/* .EntityBuilderDataSourceProvider */.D,
+        typeof _entity_builder_datasource_provider_js__rspack_import_14/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_14/* .EntityBuilderDataSourceProvider */.D,
         typeof _flusys_nestjs_shared_modules__rspack_import_3.SharedPermissionCacheService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_3.SharedPermissionCacheService,
         typeof IPermissionActionRegistry === "undefined" ? Object : IPermissionActionRegistry,
         typeof INotificationAdapter === "undefined" ? Object : INotificationAdapter,
         typeof IEmailAdapter === "undefined" ? Object : IEmailAdapter,
-        typeof ICompanyAccessResolver === "undefined" ? Object : ICompanyAccessResolver
+        typeof ICompanyAccessResolver === "undefined" ? Object : ICompanyAccessResolver,
+        typeof _entity_builder_config_service_js__rspack_import_13/* .EntityBuilderConfigService */.E === "undefined" ? Object : _entity_builder_config_service_js__rspack_import_13/* .EntityBuilderConfigService */.E
     ])
 ], 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) {
@@ -4872,7 +5562,7 @@ 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_engine_flow_types_js__rspack_import_11/* .flowEndpoints */.Xr)(flow),
+        endpoints: (0,_flow_engine_flow_types_js__rspack_import_12/* .flowEndpoints */.Xr)(flow),
         calls: calledSlugs(flow.nodes)
     };
 }
@@ -4891,6 +5581,7 @@ __webpack_require__.d(__webpack_exports__, {
   Er: defaultFlowPermissionCode,
   HF: isPublished,
   YW: flowNotFound,
+  b$: asksExecutePermission,
   j4: flowPermissions,
   lw: workingCopy
 });
@@ -4901,9 +5592,9 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(6157);
 /* import */ var typeorm__rspack_import_1 = __webpack_require__(7158);
 /* import */ var _entities_flow_execution_entity_js__rspack_import_2 = __webpack_require__(9641);
-/* import */ var _flow_engine_flow_engine_js__rspack_import_3 = __webpack_require__(8333);
-/* import */ var _flow_engine_redact_js__rspack_import_5 = __webpack_require__(2678);
-/* import */ var _entity_builder_datasource_provider_js__rspack_import_4 = __webpack_require__(424);
+/* import */ var _flow_engine_flow_engine_js__rspack_import_3 = __webpack_require__(3931);
+/* import */ var _flow_engine_redact_js__rspack_import_4 = __webpack_require__(2678);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_5 = __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") {
@@ -4947,7 +5638,7 @@ class FlowExecutionService {
     /** Never throws: a logging problem must not change the answer the caller gets. */ async record(entry) {
         try {
             const repo = await this.repo();
-            const redactedInput = (0,_flow_engine_redact_js__rspack_import_5/* .redactSensitive */.Qr)(entry.input);
+            const redactedInput = (0,_flow_engine_redact_js__rspack_import_4/* .redactSensitive */.Qr)(entry.input);
             const inputText = JSON.stringify(redactedInput ?? null);
             await repo.save(repo.create({
                 flowId: entry.flowId,
@@ -4963,7 +5654,7 @@ class FlowExecutionService {
                     _truncated: true,
                     preview: inputText.slice(0, INPUT_LIMIT_CHARS)
                 } : redactedInput,
-                output: (0,_flow_engine_redact_js__rspack_import_5/* .preview */.VH)(entry.result.body, OUTPUT_LIMIT_CHARS),
+                output: (0,_flow_engine_redact_js__rspack_import_4/* .preview */.VH)(entry.result.body, OUTPUT_LIMIT_CHARS),
                 error: entry.result.error?.slice(0, 2000) ?? null,
                 trace: entry.result.trace,
                 durationMs: entry.result.durationMs,
@@ -5057,10 +5748,10 @@ FlowExecutionService = _ts_decorate([
     (0,_nestjs_common__rspack_import_0.Injectable)({
         scope: _nestjs_common__rspack_import_0.Scope.REQUEST
     }),
-    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)(_entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)(_entity_builder_datasource_provider_js__rspack_import_5/* .EntityBuilderDataSourceProvider */.D)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof _entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D
+        typeof _entity_builder_datasource_provider_js__rspack_import_5/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_5/* .EntityBuilderDataSourceProvider */.D
     ])
 ], FlowExecutionService);
 
@@ -5103,7 +5794,7 @@ var message_keys = __webpack_require__(5732);
 // 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/flow-engine/flow-engine.ts + 6 modules
-var flow_engine = __webpack_require__(8333);
+var flow_engine = __webpack_require__(3931);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow.errors.ts
 var flow_errors = __webpack_require__(8542);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-input.validator.ts
@@ -5187,7 +5878,7 @@ class FlowUrlError extends flow_errors/* .FlowKeyedError */.Hp {
     }
     if (url.protocol !== 'http:' && url.protocol !== 'https:') throw new FlowUrlError(message_keys/* .FLOW_ERROR_MESSAGES.URL_PROTOCOL */.zr.URL_PROTOCOL);
     if (url.username || url.password) throw new FlowUrlError(message_keys/* .FLOW_ERROR_MESSAGES.URL_CREDENTIALS */.zr.URL_CREDENTIALS);
-    const host = url.hostname.replace(/^\[|\]$/g, '');
+    const host = url.hostname.replace(/^\[|\]$/g, '').replace(/\.+$/, '');
     if (!allowPrivate) {
         if (host === 'localhost' || host.endsWith('.localhost') || host.endsWith('.internal') || host.endsWith('.local')) {
             throw new FlowUrlError(message_keys/* .FLOW_ERROR_MESSAGES.URL_PRIVATE */.zr.URL_PRIVATE);
@@ -5333,8 +6024,8 @@ var entity_builder_config_service = __webpack_require__(4281);
 var entity_builder_datasource_provider = __webpack_require__(424);
 // 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.ts + 3 modules
+var generic_entity_service = __webpack_require__(3052);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/generic-entity-service.factory.ts
 var generic_entity_service_factory = __webpack_require__(7705);
 ;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/services/flow-executor.service.ts
@@ -5403,6 +6094,7 @@ class FlowExecutorService {
     email;
     branchHierarchy;
     logger = new common_.Logger(FlowExecutorService.name);
+    /** Sends still going out after their answers, for `whenPublished`. */ inFlight = new Set();
     constructor(provider, ruleEngine, moduleRef, permissionCache, config, companyAccess, notifications, email, branchHierarchy){
         this.provider = provider;
         this.ruleEngine = ruleEngine;
@@ -5496,17 +6188,17 @@ class FlowExecutorService {
             state.ownsTransaction = false;
             await qr.release().catch(()=>undefined);
         }
-        if (state.mode === 'live') await this.publishPendingEvents(state.pendingEvents, state.user);
+        if (state.mode === 'live') this.publishAfterCommit(state, state.pendingEvents.splice(0));
     }
-    /** `SET LOCAL` lasts one transaction, so every transaction a run opens sets it again. */ async limitStatementTime(qr, timeoutMs) {
-        if (await this.provider.getDriver() === 'postgres') await qr.query(`SET LOCAL statement_timeout = ${Math.max(1000, Math.floor(timeoutMs))}`);
+    async limitStatementTime(qr, timeoutMs) {
+        if (await this.provider.getDriver() === 'postgres') await qr.query((0,generic_entity_service/* .statementTimeoutSql */.xV)(timeoutMs));
     }
     async commitProgress(state) {
         const qr = state.qr;
         await qr.commitTransaction();
         await qr.startTransaction();
         await this.limitStatementTime(qr, state.deadline - Date.now());
-        await this.publishPendingEvents(state.pendingEvents.splice(0), state.user);
+        this.publishAfterCommit(state, state.pendingEvents.splice(0));
     }
     /** A multi-record step outside a transactional run: its own transaction, its record events published after it commits. */ async atomic(state, work) {
         if (state.qr) return work();
@@ -5517,6 +6209,7 @@ class FlowExecutorService {
         try {
             await qr.connect();
             await qr.startTransaction();
+            await this.limitStatementTime(qr, state.deadline - Date.now());
             state.qr = qr;
             result = await work();
             await qr.commitTransaction();
@@ -5529,7 +6222,7 @@ class FlowExecutorService {
             state.qr = undefined;
             await qr.release().catch(()=>undefined);
         }
-        await this.publishPendingEvents(state.pendingEvents.splice(queued), state.user);
+        this.publishAfterCommit(state, state.pendingEvents.splice(queued));
         return result;
     }
     /**
@@ -5560,7 +6253,7 @@ class FlowExecutorService {
             }, `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);
+        const checked = (0,flow_input_validator/* .validateEndpointInput */.GP)(start, input);
         if (checked.errors.length) {
             throw new flow_errors/* .FlowHttpError */.hk(400, 'Validation failed', checked.errors, {
                 messageKey: message_keys/* .FLOW_MESSAGES.INPUT_INVALID */.wu.INPUT_INVALID,
@@ -5590,6 +6283,9 @@ class FlowExecutorService {
                 flow.slug
             ],
             pendingEvents: parent.qr ? parent.pendingEvents : [],
+            publisher: parent.publisher ??= {
+                chain: Promise.resolve()
+            },
             trace: []
         };
         // A failed call inside the caller's transaction is rolled back with it (or to the step's savepoint), so its queued events must go too.
@@ -5624,7 +6320,6 @@ class FlowExecutorService {
             where: {
                 slug,
                 isActive: true,
-                deletedAt: (0,external_typeorm_.IsNull)(),
                 version: (0,external_typeorm_.MoreThan)(0)
             }
         });
@@ -5650,18 +6345,23 @@ class FlowExecutorService {
     }
     createEnv() {
         const entityServices = new Map();
+        /** One factory per run: one DI context, and related entities built once for every entity the run writes. */ let factory;
         /** One lookup per user for the whole run, however many steps ask. */ const access = new Map();
         let permissions;
         const env = {
             ruleEngine: this.ruleEngine,
             allowPrivateHttp: this.config.getConfig()?.flows?.allowPrivateHttp === true || process.env['ENTITY_BUILDER_FLOW_ALLOW_PRIVATE_HTTP'] === 'true',
+            codeModules: this.config.getCodeModules(),
             entityService: (entityCode, queryRunner)=>{
                 if (!entityServices.has(entityCode)) {
                     const loading = (async ()=>{
-                        const factory = await this.moduleRef.resolve(generic_entity_service_factory/* .GenericEntityServiceFactory */.G, core_.ContextIdFactory.create(), {
-                            strict: false
-                        });
-                        return factory.forEntityCode(entityCode, queryRunner);
+                        if (!factory) {
+                            factory = this.moduleRef.resolve(generic_entity_service_factory/* .GenericEntityServiceFactory */.G, core_.ContextIdFactory.create(), {
+                                strict: false
+                            });
+                            factory.catch(()=>factory = undefined);
+                        }
+                        return (await factory).forEntityCode(entityCode, queryRunner);
                     })();
                     entityServices.set(entityCode, loading);
                     // A failed load (e.g. on a transaction that later rolled back) must not be remembered for the rest of the run.
@@ -5708,6 +6408,23 @@ class FlowExecutorService {
         };
         return env;
     }
+    /**
+   * Queues `events` behind the ones this run already queued, so they go out in commit order, without holding up
+   * the answer. Runs never wait on each other (one slow listener cannot stall another caller's events). Nothing
+   * to wait for: a failing publish or send is logged, never turned into an error.
+   */ publishAfterCommit(state, events) {
+        if (!events.length) return;
+        const publisher = state.publisher ??= {
+            chain: Promise.resolve()
+        };
+        const sent = publisher.chain.then(()=>this.publishPendingEvents(events, state.user));
+        publisher.chain = sent;
+        this.inFlight.add(sent);
+        void sent.finally(()=>this.inFlight.delete(sent));
+    }
+    /** Resolves once everything queued so far went out (or failed and was logged). */ async whenPublished() {
+        while(this.inFlight.size)await Promise.all(this.inFlight);
+    }
     /** 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) {
         for (const event of events){
             try {
@@ -5802,16 +6519,20 @@ FlowExecutorService = _ts_decorate([
 
 },
 2300(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(6157);
-/* import */ var typeorm__rspack_import_1 = __webpack_require__(7158);
-/* import */ var _config_message_keys_js__rspack_import_9 = __webpack_require__(5732);
-/* import */ var _entities_flow_definition_entity_js__rspack_import_2 = __webpack_require__(3770);
-/* 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__(5229);
-/* import */ var _flow_execution_service_js__rspack_import_7 = __webpack_require__(7810);
-/* import */ var _flow_executor_service_js__rspack_import_8 = __webpack_require__(3908);
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(6937);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_1 = __webpack_require__(1236);
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_2 = __webpack_require__(9216);
+/* 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_13 = __webpack_require__(982);
+/* import */ var _config_message_keys_js__rspack_import_12 = __webpack_require__(5732);
+/* import */ var _entities_flow_definition_entity_js__rspack_import_5 = __webpack_require__(3770);
+/* import */ var _flow_engine_flow_input_validator_js__rspack_import_6 = __webpack_require__(6390);
+/* import */ var _flow_engine_flow_types_js__rspack_import_7 = __webpack_require__(6256);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_8 = __webpack_require__(424);
+/* import */ var _flow_definition_service_js__rspack_import_9 = __webpack_require__(5229);
+/* import */ var _flow_execution_service_js__rspack_import_10 = __webpack_require__(7810);
+/* import */ var _flow_executor_service_js__rspack_import_11 = __webpack_require__(3908);
 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") {
@@ -5845,6 +6566,11 @@ function _ts_param(paramIndex, decorator) {
 
 
 
+
+
+
+
+const ACTIVE_FLOW_TTL_MS = 60_000;
 const HIDDEN_HEADERS = new Set([
     'authorization',
     'cookie',
@@ -5908,7 +6634,7 @@ const inputRejected = (errors)=>({
         body: {
             success: false,
             message: 'Validation failed',
-            messageKey: _config_message_keys_js__rspack_import_9/* .FLOW_MESSAGES.INPUT_INVALID */.wu.INPUT_INVALID,
+            messageKey: _config_message_keys_js__rspack_import_12/* .FLOW_MESSAGES.INPUT_INVALID */.wu.INPUT_INVALID,
             errors
         },
         trace: [],
@@ -5919,31 +6645,64 @@ class FlowRuntimeService {
     executor;
     executions;
     definitions;
-    constructor(provider, executor, executions, definitions){
+    cache;
+    utils;
+    constructor(provider, executor, executions, definitions, cache, utils){
         this.provider = provider;
         this.executor = executor;
         this.executions = executions;
         this.definitions = definitions;
+        this.cache = cache;
+        this.utils = utils;
     }
-    /** A flow never published is not live yet: 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({
+    /**
+   * A flow never published is not live yet: it looks the same as an unknown one. Cached under the flow definitions'
+   * stamp, which every flow save / publish / delete, schema change and bundle import moves - so no caller runs a
+   * replaced flow. Without a reachable cache the read goes straight to the database.
+   */ async findActive(slug) {
+        const key = await this.activeFlowKey(slug);
+        if (key) {
+            const cached = await this.cache.get(key).catch(()=>undefined);
+            if (cached) return cached.flow;
+        }
+        const flow = await (await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_5/* .FlowDefinition */.G)).findOne({
             where: {
                 slug,
                 isActive: true,
-                deletedAt: (0,typeorm__rspack_import_1.IsNull)(),
-                version: (0,typeorm__rspack_import_1.MoreThan)(0)
+                version: (0,typeorm__rspack_import_4.MoreThan)(0)
             }
         });
+        if (key) await this.cache.set(key, {
+            flow
+        }, ACTIVE_FLOW_TTL_MS).catch(()=>undefined);
+        return flow;
+    }
+    /** Read BEFORE the database, like ApiService: a write committing mid-read moves the stamp, so the stale row lands under a key nobody asks for. */ async activeFlowKey(slug) {
+        if (!this.cache || !this.utils) return null;
+        try {
+            const tenant = (0,_flusys_nestjs_shared_utils__rspack_import_2.cacheTenantId)(this.provider);
+            const stamp = await this.utils.getCacheStamp(this.cache, [
+                _config_event_actions_js__rspack_import_13/* .ENTITY_BUILDER_EVENT_ENTITIES.FLOW_DEFINITION */.P.FLOW_DEFINITION
+            ], tenant);
+            return this.utils.getCacheKey(_config_event_actions_js__rspack_import_13/* .ENTITY_BUILDER_EVENT_ENTITIES.FLOW_DEFINITION */.P.FLOW_DEFINITION, {
+                activeSlug: slug
+            }, undefined, tenant, stamp);
+        } catch  {
+            return null;
+        }
+    }
+    /** The tenant of this request ('' for a single database): tenant databases cloned from one template share flow ids. */ tenantScope() {
+        return (0,_flusys_nestjs_shared_utils__rspack_import_2.cacheTenantId)(this.provider) ?? '';
     }
     /** The public entry: a caller hit `POST api-flows/:slug` or `POST api-flows/:slug/:endpoint`. */ async handle(flow, endpoint, body, caller, user) {
         const startedAt = new Date();
-        const checked = (0,_flow_engine_flow_input_validator_js__rspack_import_3/* .validateFlowInput */.v)(endpoint.inputSchema, body, endpoint.bodyType);
+        const checked = (0,_flow_engine_flow_input_validator_js__rspack_import_6/* .validateEndpointInput */.GP)(endpoint, body);
         if (checked.errors.length) {
             const result = inputRejected(checked.errors);
-            await this.logWebhook(flow, endpoint, body, result, startedAt, user, caller);
+            this.logWebhook(flow, endpoint, body, result, startedAt, user, caller);
             return result;
         }
-        const result = await this.executor.run((0,_flow_definition_service_js__rspack_import_6/* .toFlowSettings */.RK)(flow), {
+        const result = await this.executor.run((0,_flow_definition_service_js__rspack_import_9/* .toFlowSettings */.RK)(flow), {
             mode: 'live',
             user,
             input: checked.values,
@@ -5952,7 +6711,7 @@ class FlowRuntimeService {
             authorization: callerAuthorization(caller, user),
             exposeDetails: false
         });
-        await this.logWebhook(flow, endpoint, checked.values, result, startedAt, user, caller);
+        this.logWebhook(flow, endpoint, checked.values, result, startedAt, user, caller);
         return result;
     }
     /** The designer's "Test run": a saved flow or an unsaved draft. */ async testRun(dto, user, caller) {
@@ -5963,17 +6722,17 @@ 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);
+            settings = (0,_flow_definition_service_js__rspack_import_9/* .toFlowSettings */.RK)(dto.definition);
         } else if (flow) {
-            settings = (0,_flow_definition_service_js__rspack_import_6/* .toFlowSettings */.RK)(flow);
+            settings = (0,_flow_definition_service_js__rspack_import_9/* .toFlowSettings */.RK)(flow);
         } else {
-            throw new _nestjs_common__rspack_import_0.BadRequestException({
+            throw new _nestjs_common__rspack_import_3.BadRequestException({
                 message: 'Send a flowId or a definition to test.',
-                messageKey: _config_message_keys_js__rspack_import_9/* .FLOW_MESSAGES.NOTHING_TO_TEST */.wu.NOTHING_TO_TEST
+                messageKey: _config_message_keys_js__rspack_import_12/* .FLOW_MESSAGES.NOTHING_TO_TEST */.wu.NOTHING_TO_TEST
             });
         }
         const mode = dto.mode ?? 'dry_run';
-        const endpoint = (0,_flow_engine_flow_types_js__rspack_import_4/* .findEndpoint */.vS)(settings, dto.endpoint);
+        const endpoint = (0,_flow_engine_flow_types_js__rspack_import_7/* .findEndpoint */.vS)(settings, dto.endpoint);
         // Checked before anything runs.
         await this.definitions.assertMayTest(settings, endpoint, user, {
             mode,
@@ -5981,9 +6740,9 @@ class FlowRuntimeService {
             saved: !!flow
         });
         if (!endpoint) {
-            throw new _nestjs_common__rspack_import_0.BadRequestException({
+            throw new _nestjs_common__rspack_import_3.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,
+                messageKey: _config_message_keys_js__rspack_import_12/* .FLOW_MESSAGES.ENDPOINT_NOT_FOUND */.wu.ENDPOINT_NOT_FOUND,
                 messageVariables: {
                     endpoint: dto.endpoint ?? ''
                 }
@@ -5991,9 +6750,9 @@ class FlowRuntimeService {
         }
         const validation = await this.definitions.validate(settings);
         if (validation.errors.length) {
-            throw new _nestjs_common__rspack_import_0.BadRequestException({
+            throw new _nestjs_common__rspack_import_3.BadRequestException({
                 message: 'The flow has problems.',
-                messageKey: _config_message_keys_js__rspack_import_9/* .FLOW_MESSAGES.INVALID */.wu.INVALID,
+                messageKey: _config_message_keys_js__rspack_import_12/* .FLOW_MESSAGES.INVALID */.wu.INVALID,
                 errors: validation.errors.map((error)=>({
                         field: 'flow',
                         ...error
@@ -6003,7 +6762,7 @@ class FlowRuntimeService {
         const startedAt = new Date();
         const simulated = simulatedCaller(caller, dto.request);
         const body = dto.input ?? (endpoint.bodyType === 'list' ? [] : {});
-        const checked = (0,_flow_engine_flow_input_validator_js__rspack_import_3/* .validateFlowInput */.v)(endpoint.inputSchema, body, endpoint.bodyType);
+        const checked = (0,_flow_engine_flow_input_validator_js__rspack_import_6/* .validateEndpointInput */.GP)(endpoint, body);
         const result = checked.errors.length ? inputRejected(checked.errors) : await this.executor.run(settings, {
             mode,
             user,
@@ -6032,8 +6791,8 @@ class FlowRuntimeService {
             warnings: validation.warnings
         };
     }
-    async logWebhook(flow, endpoint, input, result, startedAt, user, caller) {
-        await this.executions.record({
+    /** Written after the answer is on its way: `record` never throws, and a live caller never waits for the log. */ logWebhook(flow, endpoint, input, result, startedAt, user, caller) {
+        void this.executions.record({
             flowId: flow.id,
             flowSlug: flow.slug,
             flowVersion: flow.version,
@@ -6050,19 +6809,25 @@ class FlowRuntimeService {
     }
 }
 FlowRuntimeService = _ts_decorate([
-    (0,_nestjs_common__rspack_import_0.Injectable)({
-        scope: _nestjs_common__rspack_import_0.Scope.REQUEST
+    (0,_nestjs_common__rspack_import_3.Injectable)({
+        scope: _nestjs_common__rspack_import_3.Scope.REQUEST
     }),
-    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)(_entity_builder_datasource_provider_js__rspack_import_5/* .EntityBuilderDataSourceProvider */.D)),
-    _ts_param(1, (0,_nestjs_common__rspack_import_0.Inject)(_flow_executor_service_js__rspack_import_8/* .FlowExecutorService */.F)),
-    _ts_param(2, (0,_nestjs_common__rspack_import_0.Inject)(_flow_execution_service_js__rspack_import_7/* .FlowExecutionService */.A)),
-    _ts_param(3, (0,_nestjs_common__rspack_import_0.Inject)(_flow_definition_service_js__rspack_import_6/* .FlowDefinitionService */.Tk)),
+    _ts_param(0, (0,_nestjs_common__rspack_import_3.Inject)(_entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_3.Inject)(_flow_executor_service_js__rspack_import_11/* .FlowExecutorService */.F)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_3.Inject)(_flow_execution_service_js__rspack_import_10/* .FlowExecutionService */.A)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_3.Inject)(_flow_definition_service_js__rspack_import_9/* .FlowDefinitionService */.Tk)),
+    _ts_param(4, (0,_nestjs_common__rspack_import_3.Optional)()),
+    _ts_param(4, (0,_nestjs_common__rspack_import_3.Inject)('CACHE_INSTANCE')),
+    _ts_param(5, (0,_nestjs_common__rspack_import_3.Optional)()),
+    _ts_param(5, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared_modules__rspack_import_1.UtilsService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof _entity_builder_datasource_provider_js__rspack_import_5/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_5/* .EntityBuilderDataSourceProvider */.D,
-        typeof _flow_executor_service_js__rspack_import_8/* .FlowExecutorService */.F === "undefined" ? Object : _flow_executor_service_js__rspack_import_8/* .FlowExecutorService */.F,
-        typeof _flow_execution_service_js__rspack_import_7/* .FlowExecutionService */.A === "undefined" ? Object : _flow_execution_service_js__rspack_import_7/* .FlowExecutionService */.A,
-        typeof _flow_definition_service_js__rspack_import_6/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_6/* .FlowDefinitionService */.Tk
+        typeof _entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D,
+        typeof _flow_executor_service_js__rspack_import_11/* .FlowExecutorService */.F === "undefined" ? Object : _flow_executor_service_js__rspack_import_11/* .FlowExecutorService */.F,
+        typeof _flow_execution_service_js__rspack_import_10/* .FlowExecutionService */.A === "undefined" ? Object : _flow_execution_service_js__rspack_import_10/* .FlowExecutionService */.A,
+        typeof _flow_definition_service_js__rspack_import_9/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_9/* .FlowDefinitionService */.Tk,
+        typeof _flusys_nestjs_shared_classes__rspack_import_0.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_0.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_1.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_1.UtilsService
     ])
 ], FlowRuntimeService);
 
@@ -6075,13 +6840,12 @@ __webpack_require__.d(__webpack_exports__, {
 },
 7705(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(6157);
-/* import */ var typeorm__rspack_import_1 = __webpack_require__(7158);
-/* import */ var _config_message_keys_js__rspack_import_7 = __webpack_require__(5732);
-/* import */ var _entities_entity_definition_entity_js__rspack_import_2 = __webpack_require__(3189);
-/* import */ var _entities_field_definition_entity_js__rspack_import_3 = __webpack_require__(2206);
-/* import */ var _entity_builder_datasource_provider_js__rspack_import_4 = __webpack_require__(424);
-/* import */ var _generic_entity_service_js__rspack_import_5 = __webpack_require__(3998);
-/* import */ var _schema_registry_service_js__rspack_import_6 = __webpack_require__(2134);
+/* import */ var _config_message_keys_js__rspack_import_6 = __webpack_require__(5732);
+/* import */ var _entities_entity_definition_entity_js__rspack_import_1 = __webpack_require__(3189);
+/* import */ var _entity_builder_config_service_js__rspack_import_2 = __webpack_require__(4281);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_3 = __webpack_require__(424);
+/* import */ var _generic_entity_service_js__rspack_import_4 = __webpack_require__(3052);
+/* import */ var _schema_registry_service_js__rspack_import_5 = __webpack_require__(2134);
 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") {
@@ -6112,13 +6876,15 @@ function _ts_param(paramIndex, decorator) {
 
 
 
-
 class GenericEntityServiceFactory {
     schemaRegistry;
     dataSourceProvider;
-    constructor(schemaRegistry, dataSourceProvider){
+    config;
+    /** A RELATION target, built once per factory however many rows and fields point at it. */ relatedById = new Map();
+    constructor(schemaRegistry, dataSourceProvider, config){
         this.schemaRegistry = schemaRegistry;
         this.dataSourceProvider = dataSourceProvider;
+        this.config = config;
     }
     /** `queryRunner`: an open transaction to read the metadata on, so the caller never needs a second pooled connection while holding one. */ async forEntityCode(entityCode, queryRunner) {
         return this.build({
@@ -6130,44 +6896,49 @@ class GenericEntityServiceFactory {
             id: entityDefinitionId
         }, entityDefinitionId, queryRunner);
     }
+    related(entityDefinitionId, queryRunner) {
+        let loading = this.relatedById.get(entityDefinitionId);
+        if (!loading) {
+            loading = this.forEntityDefinitionId(entityDefinitionId, queryRunner);
+            this.relatedById.set(entityDefinitionId, loading);
+            loading.catch(()=>this.relatedById.delete(entityDefinitionId));
+        }
+        return loading;
+    }
     async build(where, reference, queryRunner) {
-        const definitionRepository = queryRunner ? queryRunner.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_2/* .EntityDefinition */.f) : await this.dataSourceProvider.getRepository(_entities_entity_definition_entity_js__rspack_import_2/* .EntityDefinition */.f);
+        await this.schemaRegistry.warmUp(queryRunner);
+        const definitionRepository = queryRunner ? queryRunner.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_1/* .EntityDefinition */.f) : await this.dataSourceProvider.getRepository(_entities_entity_definition_entity_js__rspack_import_1/* .EntityDefinition */.f);
         const definition = await definitionRepository.findOne({
             where
         });
         if (!definition) {
             throw new _nestjs_common__rspack_import_0.NotFoundException({
                 message: `Entity '${reference}' not found.`,
-                messageKey: _config_message_keys_js__rspack_import_7/* .ENTITY_DEFINITION_MESSAGES.NOT_FOUND */.pL.NOT_FOUND,
+                messageKey: _config_message_keys_js__rspack_import_6/* .ENTITY_DEFINITION_MESSAGES.NOT_FOUND */.pL.NOT_FOUND,
                 messageVariables: {
                     id: reference
                 }
             });
         }
-        const fieldRepository = queryRunner ? queryRunner.manager.getRepository(_entities_field_definition_entity_js__rspack_import_3/* .FieldDefinition */.c) : await this.dataSourceProvider.getRepository(_entities_field_definition_entity_js__rspack_import_3/* .FieldDefinition */.c);
-        const fields = await fieldRepository.find({
-            where: {
-                entityDefinitionId: definition.id,
-                deprecatedAt: (0,typeorm__rspack_import_1.IsNull)()
-            },
-            order: {
-                order: 'ASC'
-            }
+        const { schema, fields } = await this.schemaRegistry.resolve(definition, queryRunner);
+        return new _generic_entity_service_js__rspack_import_4/* .GenericEntityService */.GK(definition, schema, fields, this.dataSourceProvider, (targetId, runner)=>this.related(targetId, runner), {
+            fastUpdates: this.config?.isFastUpdatesEnabled() ?? true
         });
-        const schema = await this.schemaRegistry.getSchema(definition.id, queryRunner);
-        return new _generic_entity_service_js__rspack_import_5/* .GenericEntityService */.GK(definition, schema, fields, this.dataSourceProvider, (targetId, runner)=>this.forEntityDefinitionId(targetId, runner));
     }
 }
 GenericEntityServiceFactory = _ts_decorate([
     (0,_nestjs_common__rspack_import_0.Injectable)({
         scope: _nestjs_common__rspack_import_0.Scope.REQUEST
     }),
-    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)(_schema_registry_service_js__rspack_import_6/* .SchemaRegistryService */.C)),
-    _ts_param(1, (0,_nestjs_common__rspack_import_0.Inject)(_entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)(_schema_registry_service_js__rspack_import_5/* .SchemaRegistryService */.C)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_0.Inject)(_entity_builder_datasource_provider_js__rspack_import_3/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_0.Optional)()),
+    _ts_param(2, (0,_nestjs_common__rspack_import_0.Inject)(_entity_builder_config_service_js__rspack_import_2/* .EntityBuilderConfigService */.E)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof _schema_registry_service_js__rspack_import_6/* .SchemaRegistryService */.C === "undefined" ? Object : _schema_registry_service_js__rspack_import_6/* .SchemaRegistryService */.C,
-        typeof _entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_4/* .EntityBuilderDataSourceProvider */.D
+        typeof _schema_registry_service_js__rspack_import_5/* .SchemaRegistryService */.C === "undefined" ? Object : _schema_registry_service_js__rspack_import_5/* .SchemaRegistryService */.C,
+        typeof _entity_builder_datasource_provider_js__rspack_import_3/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_3/* .EntityBuilderDataSourceProvider */.D,
+        typeof _entity_builder_config_service_js__rspack_import_2/* .EntityBuilderConfigService */.E === "undefined" ? Object : _entity_builder_config_service_js__rspack_import_2/* .EntityBuilderConfigService */.E
     ])
 ], GenericEntityServiceFactory);
 
@@ -6177,29 +6948,101 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 },
-3998(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(6937);
-/* import */ var _flusys_nestjs_shared_utils__rspack_import_1 = __webpack_require__(9216);
-/* import */ var _nestjs_common__rspack_import_2 = __webpack_require__(6157);
-/* import */ var _config_event_actions_js__rspack_import_10 = __webpack_require__(982);
-/* import */ var _config_message_keys_js__rspack_import_8 = __webpack_require__(5732);
-/* import */ var _enums_entity_status_enum_js__rspack_import_9 = __webpack_require__(1313);
-/* import */ var _enums_field_type_enum_js__rspack_import_7 = __webpack_require__(9614);
-/* import */ var _interfaces_generic_record_interface_js__rspack_import_3 = __webpack_require__(3372);
-/* import */ var _database_error_mapper_js__rspack_import_4 = __webpack_require__(8323);
-/* import */ var _field_value_validator_js__rspack_import_5 = __webpack_require__(3525);
-/* import */ var _schema_columns_js__rspack_import_6 = __webpack_require__(5313);
+3052(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  zb: () => (/* binding */ ACTOR_BRANCH_METADATA_KEY),
+  GK: () => (/* binding */ GenericEntityService),
+  DG: () => (/* binding */ actorMetadata),
+  xV: () => (/* binding */ statementTimeoutSql)
+});
 
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/classes"
+var classes_ = __webpack_require__(6937);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/utils"
+var utils_ = __webpack_require__(9216);
+// 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/enums/entity-status.enum.ts
+var entity_status_enum = __webpack_require__(1313);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/enums/field-type.enum.ts
+var field_type_enum = __webpack_require__(9614);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/interfaces/generic-record.interface.ts
+var generic_record_interface = __webpack_require__(3372);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/database-error.mapper.ts
+var database_error_mapper = __webpack_require__(8323);
+;// CONCATENATED MODULE: external "typeorm/persistence/Subject.js"
 
+;// CONCATENATED MODULE: external "typeorm/persistence/SubjectExecutor.js"
 
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/services/save-loaded.ts
 
 
+/**
+ * `manager.save(target, entity)` for a row the caller has already read in this transaction: TypeORM's own
+ * persistence (`SubjectExecutor` - change detection, UPDATE of the changed columns, `updated_at`, reload of
+ * generated values, nulls for nullable columns left out) run against `databaseEntity`, skipping the SELECT
+ * `save()` would make to find it. `databaseEntity` must be the row as loaded, before `entity` was merged into it.
+ * Entity-builder schemas have no relations, so the cascade / relation subject builders `save()` runs have nothing to do.
+ */ async function saveLoaded(queryRunner, target, entity, databaseEntity) {
+    const metadata = queryRunner.connection.getMetadata(target).findInheritanceMetadata(entity);
+    const subject = new __rspack_external_typeorm_persistence_Subject_js_50dfc7e4.Subject({
+        metadata,
+        entity,
+        canBeInserted: true,
+        canBeUpdated: true
+    });
+    subject.databaseEntity = databaseEntity;
+    subject.databaseEntityLoaded = true;
+    const executor = new __rspack_external_typeorm_persistence_SubjectExecutor_js_7cea48f1.SubjectExecutor(queryRunner, [
+        subject
+    ]);
+    if (!executor.hasExecutableOperations) return entity;
+    const ownTransaction = !queryRunner.isTransactionActive;
+    if (ownTransaction) await queryRunner.startTransaction();
+    try {
+        await executor.execute();
+        if (ownTransaction) await queryRunner.commitTransaction();
+    } catch (error) {
+        if (ownTransaction) await queryRunner.rollbackTransaction();
+        throw error;
+    }
+    return entity;
+}
 
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/field-value-validator.ts
+var field_value_validator = __webpack_require__(3525);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-columns.ts
+var schema_columns = __webpack_require__(5313);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/services/generic-entity.service.ts
 
 
 
 
+
+
+
+
+
+
+
+
+
+const IDLE_IN_TRANSACTION_MARGIN_MS = 10_000;
+/**
+ * `SET LOCAL` lasts one transaction, so every transaction a flow run opens sets it again. The idle limit ends a
+ * transaction left open past the run's time (a connection never released) instead of letting it hold its locks.
+ */ const statementTimeoutSql = (timeoutMs)=>{
+    const statementMs = Math.max(1000, Math.floor(timeoutMs));
+    return `SET LOCAL statement_timeout = ${statementMs}; SET LOCAL idle_in_transaction_session_timeout = ${statementMs + IDLE_IN_TRANSACTION_MARGIN_MS}`;
+};
 /** The event envelope's actor carries userId/companyId but not branchId, and permissions are
  * cached per user+company+branch - so consumers that act as the original caller read the branch from here. */ const ACTOR_BRANCH_METADATA_KEY = '_actorBranchId';
 function actorMetadata(user) {
@@ -6207,7 +7050,9 @@ function actorMetadata(user) {
         [ACTOR_BRANCH_METADATA_KEY]: user.branchId
     } : {};
 }
-const SYSTEM_COLUMNS = new Set(_schema_columns_js__rspack_import_6/* .SYSTEM_COLUMN_NAMES */.mq);
+const SYSTEM_COLUMNS = new Set(schema_columns/* .SYSTEM_COLUMN_NAMES */.mq);
+const INSERT_CHUNK_ROWS = 500;
+/** Bind parameters per statement, under PostgreSQL's 65535 (MySQL allows more). */ const INSERT_CHUNK_PARAMS = 30_000;
 const FILTER_COMPARISON_SQL = {
     eq: '=',
     ne: '<>',
@@ -6223,18 +7068,13 @@ const FILTER_COMPARISON_SQL = {
     ends_with: (t)=>`%${t}`
 };
 const TEXT_FIELD_TYPES = new Set([
-    _enums_field_type_enum_js__rspack_import_7/* .FieldType.TEXT */.P.TEXT,
-    _enums_field_type_enum_js__rspack_import_7/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
-    _enums_field_type_enum_js__rspack_import_7/* .FieldType.EMAIL */.P.EMAIL,
-    _enums_field_type_enum_js__rspack_import_7/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT
+    field_type_enum/* .FieldType.TEXT */.P.TEXT,
+    field_type_enum/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
+    field_type_enum/* .FieldType.EMAIL */.P.EMAIL,
+    field_type_enum/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT
 ]);
 /**
- * Generic CRUD for one dynamically-defined entity, mirroring ApiService's shape
- * (transactional writes, lifecycle event publishing) but
- * operating on Record<string, unknown> against a runtime EntitySchema instead of a
- * compile-time entity class. One instance per request, produced by
- * GenericEntityServiceFactory - see that class for why this isn't itself `@Injectable`.
- *
+ * Reads and writes the records of one runtime entity (built per call by GenericEntityServiceFactory).
  * Records hold only the fields the entity designer defines: scoping them to a company or branch
  * is the flow's job, through fields such as `company_id` mapped from the caller.
  */ class GenericEntityService {
@@ -6243,15 +7083,17 @@ const TEXT_FIELD_TYPES = new Set([
     fields;
     dataSourceProvider;
     resolveRelated;
+    options;
     repository;
     activeFieldCodes;
     /** The system columns this entity's table really has - a filter or sort on any other one is refused, not sent to SQL. */ presentSystemColumns;
-    constructor(definition, schema, fields, dataSourceProvider, resolveRelated){
+    constructor(definition, schema, fields, dataSourceProvider, resolveRelated, options = {}){
         this.definition = definition;
         this.schema = schema;
         this.fields = fields;
         this.dataSourceProvider = dataSourceProvider;
         this.resolveRelated = resolveRelated;
+        this.options = options;
         this.activeFieldCodes = new Set(fields.filter((f)=>!f.deprecatedAt && !f.isSystemField).map((f)=>f.code));
         this.presentSystemColumns = new Set([
             'created_at',
@@ -6271,15 +7113,17 @@ const TEXT_FIELD_TYPES = new Set([
     }
     validateValues(values, mode) {
         const fields = this.fields.filter((f)=>!f.deprecatedAt && !f.isSystemField);
-        const { values: normalized, errors } = (0,_field_value_validator_js__rspack_import_5/* .validateRecord */.e)(fields, values, mode);
+        const { values: normalized, errors } = (0,field_value_validator/* .validateRecord */.e)(fields, values, mode);
         this.throwIfInvalid(errors);
         return normalized;
     }
     throwIfInvalid(errors) {
-        if (errors.length === 0) return;
-        throw new _nestjs_common__rspack_import_2.BadRequestException({
+        if (errors.length) throw this.invalid(errors);
+    }
+    invalid(errors) {
+        return new common_.BadRequestException({
             message: 'Validation failed',
-            messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.VALIDATION_FAILED */.j4.VALIDATION_FAILED,
+            messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.VALIDATION_FAILED */.j4.VALIDATION_FAILED,
             errors
         });
     }
@@ -6288,24 +7132,43 @@ const TEXT_FIELD_TYPES = new Set([
         const errors = [];
         for (const field of this.fields){
             const value = values[field.code];
-            if (field.fieldType !== _enums_field_type_enum_js__rspack_import_7/* .FieldType.RELATION */.P.RELATION || !field.relationTargetEntityId || typeof value !== 'string') continue;
+            if (field.fieldType !== field_type_enum/* .FieldType.RELATION */.P.RELATION || !field.relationTargetEntityId || typeof value !== 'string') continue;
             const related = await this.resolveRelated(field.relationTargetEntityId, queryRunner);
             const found = await related.exists(value, {
                 queryRunner
             });
-            if (!found) errors.push({
-                field: field.code,
-                ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_8/* .FIELD_VALIDATION_MESSAGES.RELATED_NOT_FOUND */.KE.RELATED_NOT_FOUND, {
-                    label: field.label
-                })
-            });
+            if (!found) errors.push(this.relatedNotFound(field));
         }
         this.throwIfInvalid(errors);
     }
+    relatedNotFound(field) {
+        return {
+            field: field.code,
+            ...(0,utils_.messageRef)(message_keys/* .FIELD_VALIDATION_MESSAGES.RELATED_NOT_FOUND */.KE.RELATED_NOT_FOUND, {
+                label: field.label
+            })
+        };
+    }
+    /** The ids each RELATION field of `rows` names that really exist - one query per field, however many rows. */ async existingRelatedIds(rows, queryRunner) {
+        const found = new Map();
+        if (!this.resolveRelated) return found;
+        for (const field of this.fields){
+            if (field.fieldType !== field_type_enum/* .FieldType.RELATION */.P.RELATION || !field.relationTargetEntityId) continue;
+            const ids = [
+                ...new Set(rows.map((row)=>row[field.code]).filter((value)=>typeof value === 'string'))
+            ];
+            if (!ids.length) continue;
+            const related = await this.resolveRelated(field.relationTargetEntityId, queryRunner);
+            found.set(field.code, await related.existingIds(ids, {
+                queryRunner
+            }));
+        }
+        return found;
+    }
     notFound(id) {
-        return new _nestjs_common__rspack_import_2.NotFoundException({
+        return new common_.NotFoundException({
             message: `Record '${id}' not found on entity '${this.entityCode}'.`,
-            messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.NOT_FOUND */.j4.NOT_FOUND,
+            messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.NOT_FOUND */.j4.NOT_FOUND,
             messageVariables: {
                 id,
                 entity: this.entityCode
@@ -6321,19 +7184,11 @@ const TEXT_FIELD_TYPES = new Set([
             updated_by_id: user.id
         };
     }
-    async stampDeletedBy(queryRunner, target, id, userId) {
-        if (!this.definition.isAuditEnabled) return;
-        await queryRunner.manager.update(target, [
-            id
-        ], {
-            deleted_by_id: userId
-        });
-    }
     ensureActive() {
-        if (this.definition.status === _enums_entity_status_enum_js__rspack_import_9/* .EntityStatus.DEPRECATED */.c.DEPRECATED) {
-            throw new _nestjs_common__rspack_import_2.ForbiddenException({
+        if (this.definition.status === entity_status_enum/* .EntityStatus.DEPRECATED */.c.DEPRECATED) {
+            throw new common_.ForbiddenException({
                 message: `Entity '${this.definition.code}' has been deprecated and no longer accepts writes.`,
-                messageKey: _config_message_keys_js__rspack_import_8/* .ENTITY_DEFINITION_MESSAGES.DEPRECATED */.pL.DEPRECATED,
+                messageKey: message_keys/* .ENTITY_DEFINITION_MESSAGES.DEPRECATED */.pL.DEPRECATED,
                 messageVariables: {
                     code: this.definition.code
                 }
@@ -6353,24 +7208,22 @@ const TEXT_FIELD_TYPES = new Set([
         }
         return this.repository;
     }
-    /** Rejects any key that isn't a real, active field on this entity - the whitelist that
-   * keeps mass-assignment and column-name-as-SQL-injection (see getFilterQuery/getSortQuery
-   * below) both structurally impossible, since only known-good column names are ever used. */ validateKeys(dto) {
+    /** Only active field codes may be written: no mass assignment, and no client key ever reaches SQL as a column name. */ validateKeys(dto) {
         for (const key of Object.keys(dto)){
             // `id` included: an insert that names an id would overwrite the record that has it.
             if (SYSTEM_COLUMNS.has(key)) {
-                throw new _nestjs_common__rspack_import_2.BadRequestException({
+                throw new common_.BadRequestException({
                     message: `'${key}' is a system column and cannot be set directly.`,
-                    messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.SYSTEM_COLUMN_READONLY */.j4.SYSTEM_COLUMN_READONLY,
+                    messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.SYSTEM_COLUMN_READONLY */.j4.SYSTEM_COLUMN_READONLY,
                     messageVariables: {
                         key
                     }
                 });
             }
             if (!this.activeFieldCodes.has(key)) {
-                throw new _nestjs_common__rspack_import_2.BadRequestException({
+                throw new common_.BadRequestException({
                     message: `'${key}' is not a field on entity '${this.entityCode}'.`,
-                    messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.UNKNOWN_FIELD */.j4.UNKNOWN_FIELD,
+                    messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.UNKNOWN_FIELD */.j4.UNKNOWN_FIELD,
                     messageVariables: {
                         key,
                         entity: this.entityCode
@@ -6398,6 +7251,71 @@ const TEXT_FIELD_TYPES = new Set([
             };
         }, user);
     }
+    /**
+   * The checks `insert` makes before touching the table, for a caller that inserts several rows in one
+   * statement (`insertValidated`): the same errors, thrown at the same row. Returns the values to insert.
+   */ prepareInsert(dto) {
+        this.ensureActive();
+        this.validateKeys(dto);
+        return this.validateValues(dto, 'insert');
+    }
+    /** The first of `rows` (in order) naming a related record that does not exist, as `insert` would reject it - one query per RELATION field. */ async firstMissingRelation(rows, queryRunner) {
+        try {
+            const existing = await this.existingRelatedIds(rows, queryRunner);
+            for(let index = 0; index < rows.length; index++){
+                const errors = this.missingRelations(rows[index], existing);
+                if (errors.length) return {
+                    index,
+                    error: this.invalid(errors)
+                };
+            }
+            return null;
+        } catch (error) {
+            throw (0,database_error_mapper/* .mapDatabaseError */.E)(error, [
+                ...this.activeFieldCodes
+            ]);
+        }
+    }
+    /**
+   * Rows from `prepareInsert`, whose relations were checked, in one multi-row statement per chunk - each saved record
+   * comes back as `insert` returns it. On the caller's transaction, which publishes the events.
+   */ async insertValidated(rows, user, options) {
+        const repository = await this.ensureRepository();
+        return this.withTransaction({
+            ...options,
+            publishEvents: false
+        }, async (queryRunner)=>{
+            const entities = rows.map((values)=>repository.create({
+                    ...values,
+                    ...this.auditFields('created', user)
+                }));
+            const chunk = Math.max(1, Math.min(INSERT_CHUNK_ROWS, Math.floor(INSERT_CHUNK_PARAMS / (this.activeFieldCodes.size + 6))));
+            for(let start = 0; start < entities.length; start += chunk){
+                await queryRunner.manager.createQueryBuilder().insert().into(repository.target).values(entities.slice(start, start + chunk)).execute();
+            }
+            // What `save()` adds to a record it inserted: a nullable column left out reads back as null.
+            const nullable = repository.metadata.columns.filter((column)=>column.isNullable && !column.isVirtual && !column.isDeleteDate);
+            for (const entity of entities){
+                for (const column of nullable)if (column.getEntityValue(entity) === undefined) column.setEntityValue(entity, null);
+            }
+            return {
+                saved: entities,
+                events: []
+            };
+        }, user);
+    }
+    /** No unique field: a multi-row insert then fails only where a row-by-row one would, so the two answer alike. */ get batchInsertable() {
+        return !this.fields.some((f)=>f.unique && !f.deprecatedAt && !f.isSystemField);
+    }
+    missingRelations(values, existing) {
+        const errors = [];
+        for (const field of this.fields){
+            const value = values[field.code];
+            const known = existing.get(field.code);
+            if (known && typeof value === 'string' && !known.has(value)) errors.push(this.relatedNotFound(field));
+        }
+        return errors;
+    }
     async update(dto, user, options = {}) {
         this.ensureActive();
         this.assertUpdatable(dto);
@@ -6426,6 +7344,42 @@ const TEXT_FIELD_TYPES = new Set([
         });
         return queryRunner.manager.save(repository.target, entity);
     }
+    /**
+   * `update` of a record the caller has just read in this transaction (an update by filter's matches): the same
+   * checks and result, without reading it again. Falls back to `update` when `fastUpdates` is off.
+   */ async updateLoaded(row, dto, user, options = {}) {
+        const { id: _id, ...values } = dto;
+        if (this.options.fastUpdates === false) return this.update({
+            ...values,
+            id: row.id
+        }, user, options);
+        this.ensureActive();
+        this.assertUpdatable({
+            ...values,
+            id: row.id
+        });
+        const repository = await this.ensureRepository();
+        return this.withTransaction(options, async (queryRunner)=>{
+            const validated = this.validateValues(values, 'update');
+            await this.assertRelationsExist(validated, queryRunner);
+            const saved = await saveLoaded(queryRunner, repository.target, Object.assign({
+                ...row
+            }, validated, this.auditFields('updated', user)), {
+                ...row
+            });
+            return {
+                saved,
+                events: [
+                    {
+                        action: 'updated',
+                        rows: [
+                            saved
+                        ]
+                    }
+                ]
+            };
+        }, user);
+    }
     async updateRow(dto, user, repository, queryRunner) {
         const { id, ...rest } = dto;
         const existing = await queryRunner.manager.findOne(repository.target, {
@@ -6436,40 +7390,40 @@ const TEXT_FIELD_TYPES = new Set([
         if (!existing) throw this.notFound(id);
         const validated = this.validateValues(rest, 'update');
         await this.assertRelationsExist(validated, queryRunner);
-        const merged = Object.assign(existing, validated, this.auditFields('updated', user));
-        return queryRunner.manager.save(repository.target, merged);
+        if (this.options.fastUpdates === false) {
+            return queryRunner.manager.save(repository.target, Object.assign(existing, validated, this.auditFields('updated', user)));
+        }
+        const loaded = {
+            ...existing
+        };
+        return saveLoaded(queryRunner, repository.target, Object.assign(existing, validated, this.auditFields('updated', user)), loaded);
     }
     assertUpdatable(dto) {
         if (!dto.id) {
-            throw new _nestjs_common__rspack_import_2.BadRequestException({
+            throw new common_.BadRequestException({
                 message: 'id is required to update a record.',
-                messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.ID_REQUIRED */.j4.ID_REQUIRED
+                messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.ID_REQUIRED */.j4.ID_REQUIRED
             });
         }
         const { id: _id, ...rest } = dto;
         this.validateKeys(rest);
     }
-    /** Soft-deletes the record, or deletes it for good when the entity has soft delete turned off. */ async delete(id, user, options = {}) {
+    /** Soft-deletes the record, or deletes it for good when the entity has soft delete turned off. One statement either way: no row affected = not found. */ 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: {
-                    id
-                }
+            const result = soft ? await queryRunner.manager.createQueryBuilder().update(repository.target).set({
+                deleted_at: ()=>'CURRENT_TIMESTAMP',
+                ...this.definition.isAuditEnabled ? {
+                    deleted_by_id: user?.id ?? null
+                } : {}
+            }).where('id = :id', {
+                id
+            }).andWhere('deleted_at IS NULL').execute() : await queryRunner.manager.delete(repository.target, {
+                id
             });
-            if (!existing) throw this.notFound(id);
-            if (soft) {
-                await queryRunner.manager.softDelete(repository.target, [
-                    id
-                ]);
-                await this.stampDeletedBy(queryRunner, repository.target, id, user?.id ?? null);
-            } else {
-                await queryRunner.manager.delete(repository.target, [
-                    id
-                ]);
-            }
+            if (!result.affected) throw this.notFound(id);
             const rows = [
                 {
                     id
@@ -6505,9 +7459,23 @@ const TEXT_FIELD_TYPES = new Set([
             }
         });
     }
+    /** Which of `ids` exist (soft-deleted ones do not), in one query. */ async existingIds(ids, options = {}) {
+        if (!ids.length) return new Set();
+        const repository = await this.repositoryFor(options.queryRunner);
+        const rows = await repository.find({
+            select: {
+                id: true
+            },
+            where: {
+                id: (0,external_typeorm_.In)(ids)
+            }
+        });
+        return new Set(rows.map((row)=>row.id));
+    }
     async getAll(search, query, options = {}) {
         const repository = await this.repositoryFor(options.queryRunner);
         let builder = repository.createQueryBuilder(this.entityCode);
+        if (query.withDeleted) builder.withDeleted();
         if (query.filter) {
             builder = this.applyFilter(builder, query.filter);
         }
@@ -6521,25 +7489,27 @@ const TEXT_FIELD_TYPES = new Set([
             const { currentPage, pageSize } = query.pagination;
             builder.skip(currentPage * pageSize).take(pageSize);
         }
-        const [data, total] = await builder.getManyAndCount();
+        const data = await builder.getMany();
         return {
             data,
-            total
+            total: await this.totalOf(builder, data.length, query.pagination)
         };
     }
-    /** Every filter/sort/select key is checked against the real field-code whitelist before
-   * being interpolated into the query - the same class of bug flagged in ApiService's
-   * getFilterQuery/getSortQuery (raw client-supplied keys concatenated into SQL) is
-   * structurally impossible here since an unknown key is rejected outright. Operators map
-   * to a fixed SQL table and every value is a bound parameter. */ applyFilter(query, filter) {
+    /** The page itself tells the total unless it came back full (or empty past the first page): only then is COUNT run. */ async totalOf(builder, rows, pagination) {
+        if (!pagination) return rows;
+        const offset = pagination.currentPage * pagination.pageSize;
+        if (rows < pagination.pageSize && (rows > 0 || offset === 0)) return offset + rows;
+        return builder.getCount();
+    }
+    /** Every key is checked against the field-code whitelist before it reaches SQL; operators map to fixed SQL and every value is a bound parameter. */ applyFilter(query, filter) {
         const postgres = query.connection.options.type === 'postgres';
         Object.entries(filter).forEach(([key, value], index)=>{
             this.assertKnownColumn(key);
-            if (!(0,_interfaces_generic_record_interface_js__rspack_import_3/* .isRecordFilterCondition */.t1)(value) && value !== null && typeof value === 'object') {
+            if (!(0,generic_record_interface/* .isRecordFilterCondition */.t1)(value) && value !== null && typeof value === 'object') {
                 const op = value.op;
-                if (typeof op === 'string' && !('type' in value) && !_interfaces_generic_record_interface_js__rspack_import_3/* .RECORD_FILTER_OPS.includes */.ox.includes(op)) throw this.unknownOperator(key, op);
+                if (typeof op === 'string' && !('type' in value) && !generic_record_interface/* .RECORD_FILTER_OPS.includes */.ox.includes(op)) throw this.unknownOperator(key, op);
             }
-            const { op, value: operand } = (0,_interfaces_generic_record_interface_js__rspack_import_3/* .isRecordFilterCondition */.t1)(value) ? value : {
+            const { op, value: operand } = (0,generic_record_interface/* .isRecordFilterCondition */.t1)(value) ? value : {
                 op: 'eq',
                 value
             };
@@ -6550,8 +7520,8 @@ const TEXT_FIELD_TYPES = new Set([
         return query;
     }
     /** One filter as SQL: the column is a checked field code and every value is a bound parameter. */ conditionSql(column, key, op, operand, param, postgres) {
-        const multiSelect = this.fieldTypeOf(key) === _enums_field_type_enum_js__rspack_import_7/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT;
-        switch(_interfaces_generic_record_interface_js__rspack_import_3/* .FILTER_OP_VALUE_KIND */.w9[op]){
+        const multiSelect = this.fieldTypeOf(key) === field_type_enum/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT;
+        switch(generic_record_interface/* .FILTER_OP_VALUE_KIND */.w9[op]){
             case 'none':
                 if (op === 'is_null') return [
                     `${column} IS NULL`,
@@ -6669,13 +7639,13 @@ const TEXT_FIELD_TYPES = new Set([
             operand
         ] : operand;
         if (!Array.isArray(list) || !list.every(isFilterScalar)) throw this.invalidFilterValue(key, op);
-        if (list.length > _interfaces_generic_record_interface_js__rspack_import_3/* .RECORD_FILTER_LIMITS.MAX_IN_VALUES */.M5.MAX_IN_VALUES) {
-            throw new _nestjs_common__rspack_import_2.BadRequestException({
-                message: `The '${key}' filter lists more than ${_interfaces_generic_record_interface_js__rspack_import_3/* .RECORD_FILTER_LIMITS.MAX_IN_VALUES */.M5.MAX_IN_VALUES} values.`,
-                messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.FILTER_TOO_MANY_VALUES */.j4.FILTER_TOO_MANY_VALUES,
+        if (list.length > generic_record_interface/* .RECORD_FILTER_LIMITS.MAX_IN_VALUES */.M5.MAX_IN_VALUES) {
+            throw new common_.BadRequestException({
+                message: `The '${key}' filter lists more than ${generic_record_interface/* .RECORD_FILTER_LIMITS.MAX_IN_VALUES */.M5.MAX_IN_VALUES} values.`,
+                messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.FILTER_TOO_MANY_VALUES */.j4.FILTER_TOO_MANY_VALUES,
                 messageVariables: {
                     key,
-                    max: _interfaces_generic_record_interface_js__rspack_import_3/* .RECORD_FILTER_LIMITS.MAX_IN_VALUES */.M5.MAX_IN_VALUES
+                    max: generic_record_interface/* .RECORD_FILTER_LIMITS.MAX_IN_VALUES */.M5.MAX_IN_VALUES
                 }
             });
         }
@@ -6687,11 +7657,11 @@ const TEXT_FIELD_TYPES = new Set([
     /** Text operators need a text field, multi-select operators a multi-select one, and nothing but null / blank checks reads a list or JSON field. */ assertOperatorFits(key, op) {
         const type = this.fieldTypeOf(key);
         const textField = type !== undefined && TEXT_FIELD_TYPES.has(type);
-        const fits = _interfaces_generic_record_interface_js__rspack_import_3/* .TEXT_FILTER_OPS.includes */.wk.includes(op) ? textField : _interfaces_generic_record_interface_js__rspack_import_3/* .LIST_FIELD_FILTER_OPS.includes */.yV.includes(op) ? type === _enums_field_type_enum_js__rspack_import_7/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT : _interfaces_generic_record_interface_js__rspack_import_3/* .EMPTY_FILTER_OPS.includes */.Oh.includes(op) ? textField || type === _enums_field_type_enum_js__rspack_import_7/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT : op === 'is_null' || op === 'not_null' || type !== _enums_field_type_enum_js__rspack_import_7/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT && type !== _enums_field_type_enum_js__rspack_import_7/* .FieldType.JSON */.P.JSON;
+        const fits = generic_record_interface/* .TEXT_FILTER_OPS.includes */.wk.includes(op) ? textField : generic_record_interface/* .LIST_FIELD_FILTER_OPS.includes */.yV.includes(op) ? type === field_type_enum/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT : generic_record_interface/* .EMPTY_FILTER_OPS.includes */.Oh.includes(op) ? textField || type === field_type_enum/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT : op === 'is_null' || op === 'not_null' || type !== field_type_enum/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT && type !== field_type_enum/* .FieldType.JSON */.P.JSON;
         if (!fits) {
-            throw new _nestjs_common__rspack_import_2.BadRequestException({
+            throw new common_.BadRequestException({
                 message: `The '${op}' filter cannot be used on '${key}'.`,
-                messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.FILTER_OPERATOR_NOT_FOR_FIELD */.j4.FILTER_OPERATOR_NOT_FOR_FIELD,
+                messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.FILTER_OPERATOR_NOT_FOR_FIELD */.j4.FILTER_OPERATOR_NOT_FOR_FIELD,
                 messageVariables: {
                     key,
                     op
@@ -6700,20 +7670,20 @@ const TEXT_FIELD_TYPES = new Set([
         }
     }
     unknownOperator(key, op) {
-        return new _nestjs_common__rspack_import_2.BadRequestException({
+        return new common_.BadRequestException({
             message: `'${op}' is not a filter operator.`,
-            messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.FILTER_OPERATOR_UNKNOWN */.j4.FILTER_OPERATOR_UNKNOWN,
+            messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.FILTER_OPERATOR_UNKNOWN */.j4.FILTER_OPERATOR_UNKNOWN,
             messageVariables: {
                 key,
                 op,
-                ops: _interfaces_generic_record_interface_js__rspack_import_3/* .RECORD_FILTER_OPS.join */.ox.join(', ')
+                ops: generic_record_interface/* .RECORD_FILTER_OPS.join */.ox.join(', ')
             }
         });
     }
     invalidFilterValue(key, op) {
-        return new _nestjs_common__rspack_import_2.BadRequestException({
+        return new common_.BadRequestException({
             message: `The '${key}' filter has an invalid value for '${op}'.`,
-            messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.FILTER_VALUE_INVALID */.j4.FILTER_VALUE_INVALID,
+            messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.FILTER_VALUE_INVALID */.j4.FILTER_VALUE_INVALID,
             messageVariables: {
                 key,
                 op
@@ -6740,9 +7710,9 @@ const TEXT_FIELD_TYPES = new Set([
     }
     assertKnownColumn(key) {
         if (key !== 'id' && !this.presentSystemColumns.has(key) && !this.activeFieldCodes.has(key)) {
-            throw new _nestjs_common__rspack_import_2.BadRequestException({
+            throw new common_.BadRequestException({
                 message: `'${key}' is not a field on entity '${this.entityCode}'.`,
-                messageKey: _config_message_keys_js__rspack_import_8/* .GENERIC_RECORD_MESSAGES.UNKNOWN_FIELD */.j4.UNKNOWN_FIELD,
+                messageKey: message_keys/* .GENERIC_RECORD_MESSAGES.UNKNOWN_FIELD */.j4.UNKNOWN_FIELD,
                 messageVariables: {
                     key,
                     entity: this.entityCode
@@ -6761,6 +7731,9 @@ const TEXT_FIELD_TYPES = new Set([
                 await queryRunner.connect();
                 await queryRunner.startTransaction();
                 started = true;
+                if (options.statementTimeoutMs !== undefined && queryRunner.connection.options.type === 'postgres') {
+                    await queryRunner.query(statementTimeoutSql(options.statementTimeoutMs));
+                }
             }
             const { saved, events } = await fn(queryRunner);
             if (!externalQueryRunner) {
@@ -6770,8 +7743,8 @@ const TEXT_FIELD_TYPES = new Set([
             if (options.publishEvents !== false) {
                 for (const { action, rows } of events){
                     if (!rows.length) continue;
-                    await (0,_flusys_nestjs_shared_classes__rspack_import_0.publishDomainEvent)({
-                        module: _config_event_actions_js__rspack_import_10/* .ENTITY_BUILDER_EVENT_MODULE */.S,
+                    await (0,classes_.publishDomainEvent)({
+                        module: event_actions/* .ENTITY_BUILDER_EVENT_MODULE */.S,
                         entity: this.entityCode,
                         action,
                         ids: rows.map((r)=>r.id),
@@ -6788,7 +7761,7 @@ const TEXT_FIELD_TYPES = new Set([
             if (started && !committed) {
                 await queryRunner.rollbackTransaction();
             }
-            throw (0,_database_error_mapper_js__rspack_import_4/* .mapDatabaseError */.E)(error, [
+            throw (0,database_error_mapper/* .mapDatabaseError */.E)(error, [
                 ...this.activeFieldCodes
             ]);
         } finally{
@@ -6802,13 +7775,6 @@ function isFilterScalar(value) {
     return typeof value === 'string' || typeof value === 'number' && Number.isFinite(value) || typeof value === 'boolean';
 }
 
-__webpack_require__.d(__webpack_exports__, {
-  DG: () => (actorMetadata),
-  GK: () => (GenericEntityService)
-}, {
-  zb: ACTOR_BRANCH_METADATA_KEY
-});
-
 
 },
 7259(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -6950,6 +7916,23 @@ class SchemaDialectAdapterService {
             });
         }
     }
+    /** Takes `lockKey` for the connection's session (it outlives any transaction) without waiting: false when another session holds it. */ async tryAcquireSessionLock(queryRunner, lockKey, driver) {
+        const rows = driver === 'postgres' ? await queryRunner.query('SELECT pg_try_advisory_lock(hashtext($1)) AS acquired', [
+            lockKey
+        ]) : await queryRunner.query('SELECT GET_LOCK(?, 0) AS acquired', [
+            this.lockName(lockKey)
+        ]);
+        const acquired = rows?.[0]?.acquired;
+        return acquired === true || Number(acquired) === 1;
+    }
+    /** Must run before the connection goes back to the pool, or the lock stays with it. */ async releaseSessionLock(queryRunner, lockKey, driver) {
+        if (driver === 'postgres') await queryRunner.query('SELECT pg_advisory_unlock(hashtext($1))', [
+            lockKey
+        ]);
+        else await queryRunner.query('SELECT RELEASE_LOCK(?)', [
+            this.lockName(lockKey)
+        ]);
+    }
     async releaseEntityLock(queryRunner, lockKey, driver) {
         if (driver === 'postgres') {
             // pg_advisory_xact_lock is transaction-scoped - released automatically on commit/rollback.
@@ -7019,6 +8002,8 @@ class SchemaRegistryService {
     dataSourceProvider;
     dialectAdapter;
     static cache = new Map();
+    /** Per tenant: the one-time registration of every entity's schema (see warmUp). */ static warming = new Map();
+    logger = new _nestjs_common__rspack_import_1.Logger(SchemaRegistryService.name);
     constructor(dataSourceProvider, dialectAdapter){
         this.dataSourceProvider = dataSourceProvider;
         this.dialectAdapter = dialectAdapter;
@@ -7031,6 +8016,8 @@ class SchemaRegistryService {
             }
         });
         if (!definition) {
+            // Dropped, possibly on another instance: its schema is never asked for again.
+            SchemaRegistryService.cache.delete(this.cacheKey(entityDefinitionId));
             throw new _nestjs_common__rspack_import_1.NotFoundException({
                 message: `Entity definition '${entityDefinitionId}' not found.`,
                 messageKey: _config_message_keys_js__rspack_import_8/* .ENTITY_DEFINITION_MESSAGES.NOT_FOUND */.pL.NOT_FOUND,
@@ -7039,27 +8026,70 @@ class SchemaRegistryService {
                 }
             });
         }
-        const cacheKey = this.cacheKey(entityDefinitionId);
+        return (await this.resolve(definition, queryRunner)).schema;
+    }
+    /** For a definition the caller has just read: its fields are read only when its schemaVersion is not cached yet. */ async resolve(definition, queryRunner) {
+        const cacheKey = this.cacheKey(definition.id);
         const cached = SchemaRegistryService.cache.get(cacheKey);
-        if (cached && cached.version === definition.schemaVersion) {
-            return cached.schema;
-        }
+        if (cached && cached.version === definition.schemaVersion) return cached;
         const fieldRepository = queryRunner ? queryRunner.manager.getRepository(_entities_field_definition_entity_js__rspack_import_4/* .FieldDefinition */.c) : await this.dataSourceProvider.getRepository(_entities_field_definition_entity_js__rspack_import_4/* .FieldDefinition */.c);
         const fields = await fieldRepository.find({
             where: {
-                entityDefinitionId,
+                entityDefinitionId: definition.id,
                 deprecatedAt: (0,typeorm__rspack_import_2.IsNull)()
             },
             order: {
                 order: 'ASC'
             }
         });
-        const schema = await this.buildEntitySchema(definition, fields);
-        SchemaRegistryService.cache.set(cacheKey, {
+        return this.store(definition, fields);
+    }
+    /**
+   * Once per tenant per process, before its first entity is used: every entity's schema, built from two queries
+   * and registered with ONE metadata rebuild - one by one, each first use would rebuild the metadata of the
+   * whole DataSource. Never throws (logged instead, and not retried): the per-entity path works without it.
+   */ async warmUp(queryRunner) {
+        const tenant = (0,_flusys_nestjs_shared_utils__rspack_import_0.cacheTenantId)(this.dataSourceProvider) ?? '';
+        let warming = SchemaRegistryService.warming.get(tenant);
+        if (!warming) {
+            warming = this.registerAll(queryRunner).catch((error)=>this.logger.warn(`Entity schemas are registered one by one instead: ${error.message}`));
+            SchemaRegistryService.warming.set(tenant, warming);
+        }
+        await warming;
+    }
+    async registerAll(queryRunner) {
+        const repositoryOf = async (entity)=>queryRunner ? queryRunner.manager.getRepository(entity) : this.dataSourceProvider.getRepository(entity);
+        const definitions = await (await repositoryOf(_entities_entity_definition_entity_js__rspack_import_3/* .EntityDefinition */.f)).find();
+        const fields = await (await repositoryOf(_entities_field_definition_entity_js__rspack_import_4/* .FieldDefinition */.c)).find({
+            where: {
+                deprecatedAt: (0,typeorm__rspack_import_2.IsNull)()
+            },
+            order: {
+                order: 'ASC'
+            }
+        });
+        const fieldsOf = new Map();
+        for (const field of fields)fieldsOf.set(field.entityDefinitionId, [
+            ...fieldsOf.get(field.entityDefinitionId) ?? [],
+            field
+        ]);
+        const schemas = [];
+        for (const definition of definitions){
+            const cached = SchemaRegistryService.cache.get(this.cacheKey(definition.id));
+            schemas.push(cached && cached.version === definition.schemaVersion ? cached.schema : (await this.store(definition, fieldsOf.get(definition.id) ?? [])).schema);
+        }
+        await this.dataSourceProvider.registerDynamicSchemas(schemas);
+    }
+    async store(definition, fields) {
+        const resolved = {
+            schema: await this.buildEntitySchema(definition, fields),
+            fields
+        };
+        SchemaRegistryService.cache.set(this.cacheKey(definition.id), {
             version: definition.schemaVersion,
-            schema
+            ...resolved
         });
-        return schema;
+        return resolved;
     }
     invalidate(entityDefinitionId) {
         SchemaRegistryService.cache.delete(this.cacheKey(entityDefinitionId));