@flusys/nestjs-entity-builder 9.1.2 → 9.2.1

package/fesm/870.js

@@ -383,6 +383,7 @@ _ts_decorate([
 /** Form values arrive as text: `true` / `false` become booleans, anything else is left for the validator to refuse. */ const FormBoolean = ()=>(0,class_transformer__rspack_import_1.Transform)(({ value })=>value === 'true' ? true : value === 'false' ? false : value);
 /** The form fields sent with the bundle file to plan-import / apply-import. */ class ImportBundleOptionsDto {
     deprecateMissingFields;
+    deactivateMissingFlows;
     confirm;
     expectedChecksum;
     expectedPlanChecksum;
@@ -397,6 +398,16 @@ _ts_decorate([
     (0,class_validator__rspack_import_2.IsBoolean)(),
     _ts_metadata("design:type", Boolean)
 ], ImportBundleOptionsDto.prototype, "deprecateMissingFields", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Switch off (and publish) the live flows this environment has and the bundle does not (they are kept, not deleted)',
+        default: false
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    FormBoolean(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], ImportBundleOptionsDto.prototype, "deactivateMissingFlows", void 0);
 _ts_decorate([
     (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
         description: 'apply-import: acknowledge steps that lose (or may lose) data',
@@ -461,9 +472,19 @@ __webpack_require__.d(__webpack_exports__, {
 3801(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _flusys_nestjs_shared_utils__rspack_import_0 = __webpack_require__(9216);
 /* import */ var node_crypto__rspack_import_1 = __webpack_require__(2561);
-/* import */ var _config_message_keys_js__rspack_import_2 = __webpack_require__(5732);
-/* import */ var _enums_entity_status_enum_js__rspack_import_3 = __webpack_require__(1313);
-/* import */ var _enums_field_type_enum_js__rspack_import_4 = __webpack_require__(9614);
+/* import */ var _config_message_keys_js__rspack_import_7 = __webpack_require__(5732);
+/* import */ var _enums_entity_status_enum_js__rspack_import_8 = __webpack_require__(1313);
+/* import */ var _enums_field_type_enum_js__rspack_import_9 = __webpack_require__(9614);
+/* import */ var _flow_engine_flow_types_js__rspack_import_2 = __webpack_require__(6256);
+/* import */ var _rule_engine_rule_permission_js__rspack_import_3 = __webpack_require__(5191);
+/* import */ var _rule_engine_rule_interface_js__rspack_import_4 = __webpack_require__(2354);
+/* import */ var _flow_definition_service_js__rspack_import_5 = __webpack_require__(5229);
+/* import */ var _reference_rewrite_js__rspack_import_6 = __webpack_require__(3086);
+
+
+
+
+
 
 
 
@@ -499,22 +520,10 @@ const bundleChecksum = (bundle)=>(0,node_crypto__rspack_import_1.createHash)('sh
 }
 const VARIABLE_PATTERN = /\$\{var:([A-Za-z_][A-Za-z0-9_]*)\}/g;
 /** Shorter values would be replaced inside unrelated text. */ const MIN_VARIABLE_VALUE_LENGTH = 4;
-function mapStrings(value, fn) {
-    if (typeof value === 'string') return fn(value);
-    if (Array.isArray(value)) return value.map((item)=>mapStrings(item, fn));
-    if (value && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).map(([key, item])=>[
-                key,
-                mapStrings(item, fn)
-            ]));
-    }
-    return value;
-}
 /** Only a step's settings hold environment values: its id, type, name and position are never rewritten. */ const mapConfigStrings = (nodes, fn)=>nodes.map((node)=>node?.config ? {
             ...node,
-            config: mapStrings(node.config, fn)
+            config: (0,_reference_rewrite_js__rspack_import_6/* .mapStrings */.to)(node.config, fn)
         } : node);
-const escapeRegExp = (text)=>text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 /**
  * Export: every occurrence of this environment's variable values in a step's settings becomes `${var:NAME}`
  * (longest value first; one pass, so a placeholder already written is never rewritten by a shorter value).
@@ -526,7 +535,7 @@ const escapeRegExp = (text)=>text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     if (!nameOf.size) return nodes;
     const pattern = new RegExp([
         ...nameOf.keys()
-    ].map(escapeRegExp).join('|'), 'g');
+    ].map(_reference_rewrite_js__rspack_import_6/* .escapeRe */.NF).join('|'), 'g');
     return mapConfigStrings(nodes, (text)=>text.replace(pattern, (value)=>`\${var:${nameOf.get(value)}}`));
 }
 /** Import: `${var:NAME}` in a step's settings becomes this environment's value; names it does not define are returned, not replaced. */ function applyVariables(nodes, variables) {
@@ -543,6 +552,84 @@ const escapeRegExp = (text)=>text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         ].toSorted(byCode)
     };
 }
+const UUID_PATTERN = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+/**
+ * The record, user, company and email configuration ids written into a flow's step settings (step ids
+ * are never UUIDs). Such an id belongs to the environment it was typed in: each needs a `${var:NAME}`.
+ */ function fixedIds(nodes) {
+    const ids = new Set();
+    mapConfigStrings(nodes, (text)=>{
+        for (const [id] of text.matchAll(UUID_PATTERN))ids.add(id.toLowerCase());
+        return text;
+    });
+    return [
+        ...ids
+    ].toSorted(byCode);
+}
+/** The fixed codes of a HAS_PERMISSION / HAS_ANY_PERMISSION / HAS_ALL_PERMISSIONS call; more than a check may name is refused when the flow is validated. */ function literalPermissionCodes(value) {
+    try {
+        return (0,_rule_engine_rule_permission_js__rspack_import_3/* .parsePermissionCodes */.PS)(value);
+    } catch  {
+        return [];
+    }
+}
+/**
+ * Every permission code a flow checks: the rule of each `permission` URL (the execute permission when
+ * it has none), its Permission check steps, and the codes its permission functions name as literals.
+ */ function permissionCodes(flow) {
+    const codes = new Set();
+    const add = (list)=>list.forEach((code)=>codes.add(code));
+    for (const endpoint of (0,_flow_engine_flow_types_js__rspack_import_2/* .flowEndpoints */.Xr)(flow))if (endpoint.authMode === 'permission') add((0,_flusys_nestjs_shared_utils__rspack_import_0.permissionLogicCodes)((0,_flow_definition_service_js__rspack_import_5/* .flowPermissions */.j4)(endpoint, flow.slug)));
+    const walk = (value)=>{
+        if (Array.isArray(value)) return value.forEach(walk);
+        if (!value || typeof value !== 'object') return;
+        const call = value;
+        if (call.type === 'function' && (0,_rule_engine_rule_interface_js__rspack_import_4/* .isPermissionFunction */.A8)(call.name) && call.args?.[0]?.type === 'literal') add(literalPermissionCodes(call.args[0].value));
+        Object.values(value).forEach(walk);
+    };
+    for (const node of flow.nodes){
+        if (node?.type === 'permission_check' && node.config?.['permissions']) add((0,_flusys_nestjs_shared_utils__rspack_import_0.permissionLogicCodes)(node.config['permissions']));
+        walk(node?.config);
+    }
+    return [
+        ...codes
+    ].toSorted(byCode);
+}
+const SECRET_NAME = /authorization|token|secret|api[-_]?key|password|passwd|cookie|signature|credential/i;
+const AUTH_SCHEME = /^\s*(bearer|basic|token|digest)\s+/i;
+/** Shorter written text is a scheme, a separator or a placeholder's leftovers, not a credential. */ const MIN_SECRET_LENGTH = 8;
+/** The text an expression writes itself: a literal, a template or concat parts without their `{{ ... }}` and `${var:NAME}`. */ function writtenText(expression) {
+    if (typeof expression === 'string') return expression;
+    if (!expression || typeof expression !== 'object') return '';
+    const e = expression;
+    if (e.type === 'literal') return typeof e.value === 'string' ? e.value : '';
+    if (e.type === 'template') return typeof e.template === 'string' ? e.template.replace(/\{\{[^}]*\}\}/g, '') : '';
+    if (e.type === 'concat' && Array.isArray(e.parts)) return e.parts.map(writtenText).join('');
+    return '';
+}
+const isWrittenSecret = (text)=>text.replace(VARIABLE_PATTERN, '').replace(AUTH_SCHEME, '').trim().length >= MIN_SECRET_LENGTH;
+/**
+ * HTTP steps that send a credential written into the step (a header such as `Authorization` or a query
+ * parameter such as `api_key`): an export puts it in git as plain text unless it is a `${var:NAME}`.
+ */ function writtenSecrets(nodes) {
+    const found = [];
+    for (const node of nodes.filter((n)=>n?.type === 'http_request')){
+        const config = node.config ?? {};
+        for (const [name, value] of Object.entries(config.headers ?? {})){
+            if (SECRET_NAME.test(name) && isWrittenSecret(writtenText(value))) found.push({
+                step: node.name || node.id,
+                name
+            });
+        }
+        for (const [, name, value] of writtenText(config.url).matchAll(/[?&]([^=&#]+)=([^&#]*)/g)){
+            if (SECRET_NAME.test(name) && isWrittenSecret(value)) found.push({
+                step: node.name || node.id,
+                name
+            });
+        }
+    }
+    return found;
+}
 /** Slugs the Call flow steps of a flow run. */ function calledFlowSlugs(nodes) {
     return nodes.filter((node)=>node?.type === 'call_flow' && typeof node.config?.['flowSlug'] === 'string').map((node)=>node.config['flowSlug']);
 }
@@ -613,17 +700,17 @@ function changedValues(from, to, keys) {
     const problems = [];
     const codes = new Set();
     for (const entity of entities){
-        if (codes.has(entity.code)) problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .BUNDLE_MESSAGES.DUPLICATE_ENTITY */.iX.DUPLICATE_ENTITY, {
+        if (codes.has(entity.code)) problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .BUNDLE_MESSAGES.DUPLICATE_ENTITY */.iX.DUPLICATE_ENTITY, {
             entity: entity.code
         }));
-        if (entity.status === _enums_entity_status_enum_js__rspack_import_3/* .EntityStatus.DRAFT */.c.DRAFT) problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .BUNDLE_MESSAGES.ENTITY_DRAFT_IN_BUNDLE */.iX.ENTITY_DRAFT_IN_BUNDLE, {
+        if (entity.status === _enums_entity_status_enum_js__rspack_import_8/* .EntityStatus.DRAFT */.c.DRAFT) problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .BUNDLE_MESSAGES.ENTITY_DRAFT_IN_BUNDLE */.iX.ENTITY_DRAFT_IN_BUNDLE, {
             entity: entity.code
         }));
         codes.add(entity.code);
         const fieldCodes = new Set();
         const fieldIds = new Set();
         for (const field of entity.fields){
-            if (fieldCodes.has(field.code) || fieldIds.has(field.id)) problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .BUNDLE_MESSAGES.DUPLICATE_FIELD */.iX.DUPLICATE_FIELD, {
+            if (fieldCodes.has(field.code) || fieldIds.has(field.id)) problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .BUNDLE_MESSAGES.DUPLICATE_FIELD */.iX.DUPLICATE_FIELD, {
                 entity: entity.code,
                 field: field.code
             }));
@@ -636,9 +723,9 @@ function changedValues(from, to, keys) {
         ...current.map((e)=>e.code)
     ]);
     for (const entity of entities){
-        for (const field of entity.fields.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_4/* .FieldType.RELATION */.P.RELATION && !f.deprecated)){
+        for (const field of entity.fields.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_9/* .FieldType.RELATION */.P.RELATION && !f.deprecated)){
             if (!field.relationTarget || !known.has(field.relationTarget)) {
-                problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .BUNDLE_MESSAGES.RELATION_TARGET_UNKNOWN */.iX.RELATION_TARGET_UNKNOWN, {
+                problems.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .BUNDLE_MESSAGES.RELATION_TARGET_UNKNOWN */.iX.RELATION_TARGET_UNKNOWN, {
                     entity: entity.code,
                     field: field.code,
                     target: field.relationTarget ?? ''
@@ -696,7 +783,7 @@ function changedValues(from, to, keys) {
         const first = pending[0];
         const temporary = temporaryCode(first.targetFieldId, taken);
         ordered.push(step(first, first.from, temporary, first.restored || first.waited, [
-            (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .BUNDLE_MESSAGES.RENAME_VIA_TEMPORARY */.iX.RENAME_VIA_TEMPORARY, {
+            (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .BUNDLE_MESSAGES.RENAME_VIA_TEMPORARY */.iX.RENAME_VIA_TEMPORARY, {
                 field: first.from,
                 temporary,
                 to: first.to
@@ -740,7 +827,7 @@ function changedValues(from, to, keys) {
     for (const entity of sorted){
         const target = pairs.get(entity);
         if (target && target.code !== entity.code) {
-            result.blockers.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .BUNDLE_MESSAGES.ENTITY_CODE_CHANGED */.iX.ENTITY_CODE_CHANGED, {
+            result.blockers.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .BUNDLE_MESSAGES.ENTITY_CODE_CHANGED */.iX.ENTITY_CODE_CHANGED, {
                 entity: entity.code,
                 current: target.code
             }));
@@ -752,15 +839,15 @@ function changedValues(from, to, keys) {
                 kind: 'create_entity',
                 entityCode: entity.code,
                 details: {
-                    fields: live.filter((f)=>f.fieldType !== _enums_field_type_enum_js__rspack_import_4/* .FieldType.RELATION */.P.RELATION).map((f)=>f.code)
+                    fields: live.filter((f)=>f.fieldType !== _enums_field_type_enum_js__rspack_import_9/* .FieldType.RELATION */.P.RELATION).map((f)=>f.code)
                 },
                 dependsOnEarlierStep: false,
                 entity: {
                     ...entity,
-                    fields: live.filter((f)=>f.fieldType !== _enums_field_type_enum_js__rspack_import_4/* .FieldType.RELATION */.P.RELATION)
+                    fields: live.filter((f)=>f.fieldType !== _enums_field_type_enum_js__rspack_import_9/* .FieldType.RELATION */.P.RELATION)
                 }
             });
-            for (const field of live.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_4/* .FieldType.RELATION */.P.RELATION)){
+            for (const field of live.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_9/* .FieldType.RELATION */.P.RELATION)){
                 relationAdds.push({
                     kind: 'add_field',
                     entityCode: entity.code,
@@ -773,7 +860,7 @@ function changedValues(from, to, keys) {
                     field
                 });
             }
-            if (entity.status === _enums_entity_status_enum_js__rspack_import_3/* .EntityStatus.DEPRECATED */.c.DEPRECATED) {
+            if (entity.status === _enums_entity_status_enum_js__rspack_import_8/* .EntityStatus.DEPRECATED */.c.DEPRECATED) {
                 entityUpdatesLast.push({
                     kind: 'update_entity',
                     entityCode: entity.code,
@@ -784,20 +871,20 @@ function changedValues(from, to, keys) {
                     },
                     dependsOnEarlierStep: true,
                     changes: {
-                        status: _enums_entity_status_enum_js__rspack_import_3/* .EntityStatus.DEPRECATED */.c.DEPRECATED
+                        status: _enums_entity_status_enum_js__rspack_import_8/* .EntityStatus.DEPRECATED */.c.DEPRECATED
                     }
                 });
             }
             continue;
         }
-        if (target.status === _enums_entity_status_enum_js__rspack_import_3/* .EntityStatus.DRAFT */.c.DRAFT) {
-            result.blockers.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .BUNDLE_MESSAGES.ENTITY_DRAFT_HERE */.iX.ENTITY_DRAFT_HERE, {
+        if (target.status === _enums_entity_status_enum_js__rspack_import_8/* .EntityStatus.DRAFT */.c.DRAFT) {
+            result.blockers.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_7/* .BUNDLE_MESSAGES.ENTITY_DRAFT_HERE */.iX.ENTITY_DRAFT_HERE, {
                 entity: entity.code
             }));
             continue;
         }
         const entityChanges = changedValues(target, entity, ENTITY_COMPARED_KEYS);
-        const deprecating = entityChanges['status'] === _enums_entity_status_enum_js__rspack_import_3/* .EntityStatus.DEPRECATED */.c.DEPRECATED;
+        const deprecating = entityChanges['status'] === _enums_entity_status_enum_js__rspack_import_8/* .EntityStatus.DEPRECATED */.c.DEPRECATED;
         if (Object.keys(entityChanges).length) {
             (deprecating ? entityUpdatesLast : entityUpdatesFirst).push({
                 kind: 'update_entity',
@@ -934,18 +1021,19 @@ function changedValues(from, to, keys) {
 __webpack_require__.d(__webpack_exports__, {
   Og: () => (matchDefinitions),
   Q5: () => (calledFlowSlugs),
+  QJ: () => (permissionCodes),
   dX: () => (stripApiKeys),
   dj: () => (canonicalJson),
+  f7: () => (fixedIds),
   gT: () => (applyVariables),
+  l6: () => (writtenSecrets),
   lj: () => (extractVariables),
   qG: () => (orderFlows),
   zb: () => (diffEntities)
 }, {
-  $I: ENTITY_COMPARED_KEYS,
   VU: byCode,
   bs: bundleSubject,
-  i9: bundleChecksum,
-  mT: FIELD_COMPARED_KEYS
+  i9: bundleChecksum
 });
 
 
@@ -953,22 +1041,34 @@ __webpack_require__.d(__webpack_exports__, {
 6412(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(6157);
 /* import */ var class_transformer__rspack_import_1 = __webpack_require__(5812);
-/* import */ var class_validator__rspack_import_2 = __webpack_require__(5421);
-/* import */ var _config_message_keys_js__rspack_import_4 = __webpack_require__(5732);
-/* import */ var _dtos_definition_bundle_dto_js__rspack_import_3 = __webpack_require__(6691);
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_2 = __webpack_require__(9216);
+/* import */ var class_validator__rspack_import_3 = __webpack_require__(5421);
+/* import */ var _config_entity_builder_constants_js__rspack_import_7 = __webpack_require__(6576);
+/* import */ var _config_message_keys_js__rspack_import_6 = __webpack_require__(5732);
+/* import */ var _dtos_definition_bundle_dto_js__rspack_import_4 = __webpack_require__(6691);
+/* import */ var _interfaces_definition_bundle_interface_js__rspack_import_8 = __webpack_require__(8835);
+/* import */ var _definition_bundle_diff_js__rspack_import_5 = __webpack_require__(3801);
+
+
+
+
 
 
 
 
 
 const MAX_REPORTED_PROBLEMS = 50;
-/** Every failed constraint, named by its path in the bundle (`entities.0.fields.2.code`). */ function problems(errors, parent = '') {
+/** Every failed constraint, named by its path in the bundle (`entities.0.fields.2.code`); `constraints` are class-validator's names (`isString`, `maxLength`). */ function problems(errors, parent = '') {
     return errors.flatMap((error)=>{
         const field = parent ? `${parent}.${error.property}` : error.property;
         const own = error.constraints ? [
             {
                 field,
-                message: Object.values(error.constraints).join('; ')
+                message: Object.values(error.constraints).join('; '),
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_2.messageRef)(_config_message_keys_js__rspack_import_6/* .BUNDLE_MESSAGES.FILE_VALUE_INVALID */.iX.FILE_VALUE_INVALID, {
+                    field,
+                    constraints: Object.keys(error.constraints).join(', ')
+                })
             }
         ] : [];
         return [
@@ -977,9 +1077,16 @@ const MAX_REPORTED_PROBLEMS = 50;
         ];
     });
 }
+const fileProblem = (file, message, messageKey)=>({
+        field: file,
+        message,
+        ...(0,_flusys_nestjs_shared_utils__rspack_import_2.messageRef)(messageKey, {
+            file
+        })
+    });
 const invalid = (errors = [])=>new _nestjs_common__rspack_import_0.BadRequestException({
         message: 'The file is not a valid entity builder bundle.',
-        messageKey: _config_message_keys_js__rspack_import_4/* .BUNDLE_MESSAGES.FILE_INVALID */.iX.FILE_INVALID,
+        messageKey: _config_message_keys_js__rspack_import_6/* .BUNDLE_MESSAGES.FILE_INVALID */.iX.FILE_INVALID,
         ...errors.length ? {
             errors: errors.slice(0, MAX_REPORTED_PROBLEMS)
         } : {}
@@ -987,57 +1094,94 @@ const invalid = (errors = [])=>new _nestjs_common__rspack_import_0.BadRequestExc
 /**
  * The uploaded bundle, parsed and checked as strictly as a request body (unknown keys refused). The
  * bundle travels as a file rather than as JSON so the app's JSON body limit never applies to it: the
- * upload limit is the package's own (`ENTITY_BUNDLE_MAX_BYTES`, enforced by FileInterceptor).
- */ function readBundleFile(file) {
+ * upload limit is the package's own (`ENTITY_BUNDLE_MAX_BYTES`, enforced by FilesInterceptor).
+ */ function readBundleFile(file, source = '') {
     if (!file?.buffer?.length) {
         throw new _nestjs_common__rspack_import_0.BadRequestException({
             message: 'Attach the bundle file as the "bundle" form field.',
-            messageKey: _config_message_keys_js__rspack_import_4/* .BUNDLE_MESSAGES.FILE_REQUIRED */.iX.FILE_REQUIRED
+            messageKey: _config_message_keys_js__rspack_import_6/* .BUNDLE_MESSAGES.FILE_REQUIRED */.iX.FILE_REQUIRED
         });
     }
+    const unreadable = (message, messageKey)=>invalid(source ? [
+            fileProblem(source, message, messageKey)
+        ] : []);
     let raw;
     try {
         raw = JSON.parse(file.buffer.toString('utf8').replace(/^\uFEFF/, ''));
     } catch  {
-        throw invalid();
+        throw unreadable('not valid JSON', _config_message_keys_js__rspack_import_6/* .BUNDLE_MESSAGES.FILE_NOT_JSON */.iX.FILE_NOT_JSON);
     }
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw invalid();
-    const bundle = (0,class_transformer__rspack_import_1.plainToInstance)(_dtos_definition_bundle_dto_js__rspack_import_3/* .DefinitionBundleDto */.JE, raw);
-    const errors = (0,class_validator__rspack_import_2.validateSync)(bundle, {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw unreadable('not a JSON object', _config_message_keys_js__rspack_import_6/* .BUNDLE_MESSAGES.FILE_NOT_OBJECT */.iX.FILE_NOT_OBJECT);
+    const bundle = (0,class_transformer__rspack_import_1.plainToInstance)(_dtos_definition_bundle_dto_js__rspack_import_4/* .DefinitionBundleDto */.JE, raw);
+    const errors = (0,class_validator__rspack_import_3.validateSync)(bundle, {
         whitelist: true,
         forbidNonWhitelisted: true
     });
-    if (errors.length) throw invalid(problems(errors));
+    if (errors.length) throw invalid(problems(errors, source));
     return bundle;
 }
+/**
+ * One bundle from one or more uploaded files. Every file is a complete bundle on its own - a whole export,
+ * or one file per entity and per flow as `entity-bundle export --split` writes them - so a folder kept in git
+ * can be cherry-picked file by file. Entities and flows are merged in code / slug order, the order an export
+ * writes them, so a split folder and the single file of the same definitions have the same checksum.
+ * A definition in two files is not merged here: the plan blocks it as a duplicate.
+ */ function readBundleFiles(files) {
+    if (!files?.length) return readBundleFile(undefined);
+    if (files.length === 1) return readBundleFile(files[0]);
+    if (files.reduce((total, file)=>total + file.size, 0) > _config_entity_builder_constants_js__rspack_import_7/* .ENTITY_BUNDLE_MAX_BYTES */.EA) {
+        throw new _nestjs_common__rspack_import_0.PayloadTooLargeException({
+            message: 'The bundle files are larger than the upload limit together.',
+            messageKey: _config_message_keys_js__rspack_import_6/* .BUNDLE_MESSAGES.FILES_TOO_LARGE */.iX.FILES_TOO_LARGE
+        });
+    }
+    const bundles = files.map((file, index)=>{
+        const name = file.originalname || `#${index + 1}`;
+        if (!file.buffer?.length) throw invalid([
+            fileProblem(name, 'empty file', _config_message_keys_js__rspack_import_6/* .BUNDLE_MESSAGES.FILE_EMPTY */.iX.FILE_EMPTY)
+        ]);
+        return readBundleFile(file, name);
+    });
+    return {
+        format: _interfaces_definition_bundle_interface_js__rspack_import_8/* .DEFINITION_BUNDLE_FORMAT */.D,
+        version: (/* inlined export .DEFINITION_BUNDLE_VERSION */1),
+        entities: bundles.flatMap((b)=>b.entities).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_5/* .byCode */.VU)(a.code, b.code)),
+        flows: bundles.flatMap((b)=>b.flows).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_5/* .byCode */.VU)(a.slug, b.slug))
+    };
+}
 
 __webpack_require__.d(__webpack_exports__, {
+  K: () => (readBundleFiles),
   z: () => (readBundleFile)
 });
 
 
 },
 7463(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _flusys_nestjs_shared_utils__rspack_import_0 = __webpack_require__(9216);
-/* import */ var _nestjs_common__rspack_import_1 = __webpack_require__(6157);
-/* import */ var node_crypto__rspack_import_2 = __webpack_require__(2561);
-/* import */ var typeorm__rspack_import_3 = __webpack_require__(7158);
-/* import */ var _config_message_keys_js__rspack_import_17 = __webpack_require__(5732);
-/* import */ var _dtos_schema_change_dto_js__rspack_import_4 = __webpack_require__(4945);
-/* import */ var _entities_entity_definition_entity_js__rspack_import_5 = __webpack_require__(3189);
-/* import */ var _enums_entity_status_enum_js__rspack_import_16 = __webpack_require__(1313);
-/* import */ var _entities_field_definition_entity_js__rspack_import_6 = __webpack_require__(2206);
-/* import */ var _entities_flow_definition_entity_js__rspack_import_7 = __webpack_require__(3770);
-/* import */ var _flow_engine_flow_errors_js__rspack_import_8 = __webpack_require__(8542);
-/* import */ var _flow_engine_flow_types_js__rspack_import_9 = __webpack_require__(6256);
-/* import */ var _interfaces_definition_bundle_interface_js__rspack_import_18 = __webpack_require__(8835);
-/* import */ var _interfaces_flow_definition_interface_js__rspack_import_19 = __webpack_require__(9609);
-/* import */ var _definition_bundle_diff_js__rspack_import_10 = __webpack_require__(3801);
-/* import */ var _entity_builder_config_service_js__rspack_import_11 = __webpack_require__(4281);
-/* import */ var _entity_builder_datasource_provider_js__rspack_import_12 = __webpack_require__(424);
-/* import */ var _flow_definition_service_js__rspack_import_13 = __webpack_require__(5229);
-/* import */ var _schema_evolution_service_js__rspack_import_14 = __webpack_require__(3606);
-/* import */ var _schema_sync_service_js__rspack_import_15 = __webpack_require__(3474);
+/* import */ var _flusys_nestjs_shared_interfaces__rspack_import_0 = __webpack_require__(5103);
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_1 = __webpack_require__(9216);
+/* import */ var _nestjs_common__rspack_import_2 = __webpack_require__(6157);
+/* import */ var node_crypto__rspack_import_3 = __webpack_require__(2561);
+/* import */ var typeorm__rspack_import_4 = __webpack_require__(7158);
+/* import */ var _config_message_keys_js__rspack_import_20 = __webpack_require__(5732);
+/* import */ var _dtos_schema_change_dto_js__rspack_import_5 = __webpack_require__(4945);
+/* import */ var _entities_entity_definition_entity_js__rspack_import_6 = __webpack_require__(3189);
+/* import */ var _enums_entity_status_enum_js__rspack_import_19 = __webpack_require__(1313);
+/* import */ var _enums_field_type_enum_js__rspack_import_22 = __webpack_require__(9614);
+/* import */ var _entities_field_definition_entity_js__rspack_import_7 = __webpack_require__(2206);
+/* import */ var _entities_flow_definition_entity_js__rspack_import_8 = __webpack_require__(3770);
+/* import */ var _flow_engine_flow_errors_js__rspack_import_9 = __webpack_require__(8542);
+/* import */ var _flow_engine_flow_types_js__rspack_import_10 = __webpack_require__(6256);
+/* import */ var _interfaces_definition_bundle_interface_js__rspack_import_21 = __webpack_require__(8835);
+/* import */ var _interfaces_flow_definition_interface_js__rspack_import_23 = __webpack_require__(9609);
+/* import */ var _definition_bundle_diff_js__rspack_import_11 = __webpack_require__(3801);
+/* import */ var _entity_builder_config_service_js__rspack_import_12 = __webpack_require__(4281);
+/* import */ var _entity_builder_datasource_provider_js__rspack_import_13 = __webpack_require__(424);
+/* import */ var _entity_permission_service_js__rspack_import_14 = __webpack_require__(1462);
+/* import */ var _flow_definition_service_js__rspack_import_15 = __webpack_require__(5229);
+/* import */ var _schema_dialect_adapter_service_js__rspack_import_16 = __webpack_require__(7259);
+/* import */ var _schema_evolution_service_js__rspack_import_17 = __webpack_require__(3606);
+/* import */ var _schema_sync_service_js__rspack_import_18 = __webpack_require__(3474);
 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") {
@@ -1077,16 +1221,20 @@ function _ts_param(paramIndex, decorator) {
 
 
 
+
+
+
+
 
 
 
 
 /** The reasons a failed step gives besides its message: a change's blockers, a flow's validation errors. */ function failureDetails(error) {
-    if (!(error instanceof _nestjs_common__rspack_import_1.HttpException)) return [];
+    if (!(error instanceof _nestjs_common__rspack_import_2.HttpException)) return [];
     const response = error.getResponse();
     if (typeof response !== 'object') return [];
     const details = response.blockers ?? response.errors ?? [];
-    return details.filter((d)=>typeof d?.messageKey === 'string').map((d)=>(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(d.messageKey, d.messageVariables));
+    return details.filter((d)=>typeof d?.messageKey === 'string').map((d)=>(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(d.messageKey, d.messageVariables));
 }
 /** Structural changes that, unpreviewed, may turn out to lose data (a type conversion, a column made required or unique, audit or soft delete switched off). */ const LOSSY_FIELD_CHANGES = [
     'fieldType',
@@ -1105,21 +1253,21 @@ function mayLoseData(step) {
 /**
  * What was reviewed: the bundle, the options and every step (kind, subject, changes, and whether its
  * preview loses data). Not the SQL or row counts, which change with every write and would refuse each apply.
- */ function planChecksum(bundle, deprecateMissingFields, steps) {
+ */ function planChecksum(bundle, options, steps) {
     const reviewed = steps.map((step)=>({
             kind: step.kind,
-            subject: (0,_definition_bundle_diff_js__rspack_import_10/* .bundleSubject */.bs)(step),
+            subject: (0,_definition_bundle_diff_js__rspack_import_11/* .bundleSubject */.bs)(step),
             details: step.details,
             destructive: step.preview?.destructive ?? null
         }));
-    return (0,node_crypto__rspack_import_2.createHash)('sha256').update((0,_definition_bundle_diff_js__rspack_import_10/* .canonicalJson */.dj)({
+    return (0,node_crypto__rspack_import_3.createHash)('sha256').update((0,_definition_bundle_diff_js__rspack_import_11/* .canonicalJson */.dj)({
         bundle,
-        deprecateMissingFields,
+        ...options,
         steps: reviewed
     })).digest('hex');
 }
-const newApiKey = ()=>`fk_${(0,node_crypto__rspack_import_2.randomBytes)(4).toString('hex')}_${(0,node_crypto__rspack_import_2.randomBytes)(16).toString('hex')}`;
-const triggerPath = (node)=>typeof node.config?.['path'] === 'string' && node.config['path'] ? node.config['path'] : null;
+/** One import at a time per database: two would plan against the same state and race each other's steps. */ const IMPORT_LOCK = 'eb_bundle_import';
+const newApiKey = ()=>`fk_${(0,node_crypto__rspack_import_3.randomBytes)(4).toString('hex')}_${(0,node_crypto__rspack_import_3.randomBytes)(16).toString('hex')}`;
 const needsApiKey = (node)=>node?.type === 'trigger' && node.config?.['authMode'] === 'api_key';
 /** The stored API keys of a flow's Request steps (published and draft), by step id. */ function storedApiKeys(flow) {
     const keys = new Map();
@@ -1127,7 +1275,7 @@ const needsApiKey = (node)=>node?.type === 'trigger' && node.config?.['authMode'
         ...flow?.nodes ?? [],
         ...flow?.draft?.nodes ?? []
     ]){
-        if (node?.type === 'trigger' && (0,_flow_engine_flow_types_js__rspack_import_9/* .isStoredApiKey */.xA)(node.config?.['apiKey']) && !keys.has(node.id)) keys.set(node.id, node.config['apiKey']);
+        if (node?.type === 'trigger' && (0,_flow_engine_flow_types_js__rspack_import_10/* .isStoredApiKey */.xA)(node.config?.['apiKey']) && !keys.has(node.id)) keys.set(node.id, node.config['apiKey']);
     }
     return keys;
 }
@@ -1137,66 +1285,94 @@ class DefinitionBundleService {
     schemaSync;
     evolution;
     flows;
-    constructor(provider, config, schemaSync, evolution, flows){
+    dialect;
+    actionRegistry;
+    constructor(provider, config, schemaSync, evolution, flows, dialect, actionRegistry){
         this.provider = provider;
         this.config = config;
         this.schemaSync = schemaSync;
         this.evolution = evolution;
         this.flows = flows;
-    }
-    variables() {
-        return this.config.getBundleVariables();
+        this.dialect = dialect;
+        this.actionRegistry = actionRegistry;
     }
     // ── export ──────────────────────────────────────────────────────────────────────────
     async export(dto) {
         const current = await this.loadEntities();
         const selected = dto.entityCodes ? current.filter((e)=>dto.entityCodes.includes(e.code)) : current;
         // A DRAFT entity has no table where it is designed, so there is nothing to promote yet.
-        const drafts = selected.filter((e)=>e.status === _enums_entity_status_enum_js__rspack_import_16/* .EntityStatus.DRAFT */.c.DRAFT).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_10/* .byCode */.VU)(a.code, b.code));
-        const entities = selected.filter((e)=>e.status !== _enums_entity_status_enum_js__rspack_import_16/* .EntityStatus.DRAFT */.c.DRAFT).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_10/* .byCode */.VU)(a.code, b.code)).map((entity)=>({
+        const drafts = selected.filter((e)=>e.status === _enums_entity_status_enum_js__rspack_import_19/* .EntityStatus.DRAFT */.c.DRAFT).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_11/* .byCode */.VU)(a.code, b.code));
+        const entities = selected.filter((e)=>e.status !== _enums_entity_status_enum_js__rspack_import_19/* .EntityStatus.DRAFT */.c.DRAFT).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_11/* .byCode */.VU)(a.code, b.code)).map((entity)=>({
                 ...entity,
-                fields: entity.fields.toSorted((a, b)=>a.order - b.order || (0,_definition_bundle_diff_js__rspack_import_10/* .byCode */.VU)(a.code, b.code))
+                fields: entity.fields.toSorted((a, b)=>a.order - b.order || (0,_definition_bundle_diff_js__rspack_import_11/* .byCode */.VU)(a.code, b.code))
             }));
-        const flowRepo = await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G);
+        const flowRepo = await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_8/* .FlowDefinition */.G);
         const rows = (await flowRepo.find({
             where: dto.flowSlugs ? {
-                slug: (0,typeorm__rspack_import_3.In)(dto.flowSlugs)
+                slug: (0,typeorm__rspack_import_4.In)(dto.flowSlugs)
             } : {}
-        })).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_10/* .byCode */.VU)(a.slug, b.slug));
+        })).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_11/* .byCode */.VU)(a.slug, b.slug));
         const warnings = [
-            ...drafts.map((entity)=>(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.ENTITY_DRAFT_SKIPPED */.iX.ENTITY_DRAFT_SKIPPED, {
+            ...drafts.map((entity)=>(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.ENTITY_DRAFT_SKIPPED */.iX.ENTITY_DRAFT_SKIPPED, {
                     entity: entity.code
                 })),
-            ...rows.filter((flow)=>!(0,_flow_definition_service_js__rspack_import_13/* .isPublished */.HF)(flow)).map((flow)=>(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.FLOW_UNPUBLISHED_SKIPPED */.iX.FLOW_UNPUBLISHED_SKIPPED, {
+            ...rows.filter((flow)=>!(0,_flow_definition_service_js__rspack_import_15/* .isPublished */.HF)(flow)).map((flow)=>(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOW_UNPUBLISHED_SKIPPED */.iX.FLOW_UNPUBLISHED_SKIPPED, {
                     flow: flow.slug
                 }))
         ];
-        const variables = this.variables();
-        const flows = rows.filter(_flow_definition_service_js__rspack_import_13/* .isPublished */.HF).map((flow)=>{
-            const snapshot = (0,_flow_definition_service_js__rspack_import_13/* .snapshotOf */.eY)(flow);
+        const variables = this.config.getBundleVariables();
+        const flows = rows.filter(_flow_definition_service_js__rspack_import_15/* .isPublished */.HF).map((flow)=>{
+            const snapshot = (0,_flow_definition_service_js__rspack_import_15/* .snapshotOf */.eY)(flow);
             return {
                 ...snapshot,
                 description: snapshot.description ?? null,
-                nodes: (0,_definition_bundle_diff_js__rspack_import_10/* .extractVariables */.lj)((0,_definition_bundle_diff_js__rspack_import_10/* .stripApiKeys */.dX)(snapshot.nodes ?? []), variables),
+                nodes: (0,_definition_bundle_diff_js__rspack_import_11/* .extractVariables */.lj)((0,_definition_bundle_diff_js__rspack_import_11/* .stripApiKeys */.dX)(snapshot.nodes ?? []), variables),
                 edges: snapshot.edges ?? []
             };
         });
+        warnings.push(...this.leftBehind(entities, flows));
+        for (const flow of flows){
+            for (const { step, name } of (0,_definition_bundle_diff_js__rspack_import_11/* .writtenSecrets */.l6)(flow.nodes))warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOW_SECRET_WRITTEN */.iX.FLOW_SECRET_WRITTEN, {
+                flow: flow.slug,
+                step,
+                name
+            }));
+        }
         // Keys sorted at every level: PostgreSQL and MySQL hand JSON columns back in different key orders.
-        const bundle = JSON.parse((0,_definition_bundle_diff_js__rspack_import_10/* .canonicalJson */.dj)({
-            format: _interfaces_definition_bundle_interface_js__rspack_import_18/* .DEFINITION_BUNDLE_FORMAT */.D,
+        const bundle = JSON.parse((0,_definition_bundle_diff_js__rspack_import_11/* .canonicalJson */.dj)({
+            format: _interfaces_definition_bundle_interface_js__rspack_import_21/* .DEFINITION_BUNDLE_FORMAT */.D,
             version: (/* inlined export .DEFINITION_BUNDLE_VERSION */1),
             entities,
             flows
         }));
         return {
             bundle,
-            checksum: (0,_definition_bundle_diff_js__rspack_import_10/* .bundleChecksum */.i9)(bundle),
+            checksum: (0,_definition_bundle_diff_js__rspack_import_11/* .bundleChecksum */.i9)(bundle),
             warnings
         };
     }
+    /** Relations and Call flow steps that reach outside the bundle: the environment importing it must already have their targets. */ leftBehind(entities, flows) {
+        const entityCodes = new Set(entities.map((e)=>e.code));
+        const slugs = new Set(flows.map((f)=>f.slug));
+        const relations = entities.flatMap((entity)=>entity.fields.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_22/* .FieldType.RELATION */.P.RELATION && !f.deprecated && f.relationTarget && !entityCodes.has(f.relationTarget)).map((f)=>(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.EXPORT_RELATION_LEFT_OUT */.iX.EXPORT_RELATION_LEFT_OUT, {
+                    entity: entity.code,
+                    field: f.code,
+                    target: f.relationTarget
+                })));
+        const calls = flows.flatMap((flow)=>[
+                ...new Set((0,_definition_bundle_diff_js__rspack_import_11/* .calledFlowSlugs */.Q5)(flow.nodes))
+            ].filter((slug)=>!slugs.has(slug)).toSorted(_definition_bundle_diff_js__rspack_import_11/* .byCode */.VU).map((called)=>(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.EXPORT_CALLED_FLOW_LEFT_OUT */.iX.EXPORT_CALLED_FLOW_LEFT_OUT, {
+                    flow: flow.slug,
+                    called
+                })));
+        return [
+            ...relations,
+            ...calls
+        ];
+    }
     /** Every entity of this environment with its fields, relations named by target code. */ async loadEntities() {
-        const definitions = await (await this.provider.getRepository(_entities_entity_definition_entity_js__rspack_import_5/* .EntityDefinition */.f)).find();
-        const fields = await (await this.provider.getRepository(_entities_field_definition_entity_js__rspack_import_6/* .FieldDefinition */.c)).find();
+        const definitions = await (await this.provider.getRepository(_entities_entity_definition_entity_js__rspack_import_6/* .EntityDefinition */.f)).find();
+        const fields = await (await this.provider.getRepository(_entities_field_definition_entity_js__rspack_import_7/* .FieldDefinition */.c)).find();
         const codeOf = new Map(definitions.map((d)=>[
                 d.id,
                 d.code
@@ -1237,10 +1413,12 @@ class DefinitionBundleService {
     /** The plan, with what apply-import runs: the entity operations and the flows, in order. */ async buildPlan(dto, user) {
         const bundle = dto.bundle;
         const current = await this.loadEntities();
-        const entityDiff = (0,_definition_bundle_diff_js__rspack_import_10/* .diffEntities */.zb)(bundle.entities, current, {
+        const entityDiff = (0,_definition_bundle_diff_js__rspack_import_11/* .diffEntities */.zb)(bundle.entities, current, {
             deprecateMissingFields: dto.deprecateMissingFields === true
         });
-        const flowDiff = await this.diffFlows(bundle.flows);
+        const flowDiff = await this.diffFlows(bundle.flows, {
+            deactivateMissingFlows: dto.deactivateMissingFlows === true
+        });
         const existingCodes = new Set(current.map((e)=>e.code));
         const steps = [];
         for (const operation of entityDiff.operations){
@@ -1256,7 +1434,7 @@ class DefinitionBundleService {
                 warnings: [
                     ...operation.warnings ?? [],
                     ...dependent ? [
-                        (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.STEP_AFTER_EARLIER */.iX.STEP_AFTER_EARLIER)
+                        (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.STEP_AFTER_EARLIER */.iX.STEP_AFTER_EARLIER)
                     ] : []
                 ],
                 blockers: []
@@ -1266,13 +1444,15 @@ class DefinitionBundleService {
                     step.preview = await this.previewEntityStep(operation, current, user);
                     step.blockers.push(...step.preview.blockers);
                 } catch (error) {
-                    step.blockers.push((0,_flow_engine_flow_errors_js__rspack_import_8/* .errorRef */.O$)(error));
+                    step.blockers.push((0,_flow_engine_flow_errors_js__rspack_import_9/* .errorRef */.O$)(error));
                 }
             }
             steps.push(step);
         }
         const schemaChanges = entityDiff.operations.length > 0;
-        const importedSlugs = new Set(flowDiff.planned.map((p)=>p.flow.slug));
+        // Flows switched off run last, callers first: each is still running when the flows that call it are checked.
+        const importedSlugs = new Set(flowDiff.planned.filter((p)=>p.kind !== 'deactivate_flow').map((p)=>p.flow.slug));
+        const savedFlows = [];
         for (const planned of flowDiff.planned){
             const step = {
                 kind: planned.kind,
@@ -1286,22 +1466,30 @@ class DefinitionBundleService {
                     ...planned.blockers
                 ]
             };
-            // A flow with a code step needs that permission from whoever imports it, as from whoever saves it.
-            await this.flows.assertMayAuthor((0,_flow_definition_service_js__rspack_import_13/* .toFlowSettings */.RK)(planned.flow), user).catch((error)=>step.blockers.push((0,_flow_engine_flow_errors_js__rspack_import_8/* .errorRef */.O$)(error)));
-            const dependsOnImport = schemaChanges || (0,_definition_bundle_diff_js__rspack_import_10/* .calledFlowSlugs */.Q5)(planned.flow.nodes).some((slug)=>importedSlugs.has(slug));
+            if (planned.kind !== 'deactivate_flow') savedFlows.push([
+                step,
+                planned.flow
+            ]);
+            // Switching a flow off saves it too: a flow with a code step needs that permission from whoever imports it, as from whoever saves it.
+            await this.flows.assertMayAuthor((0,_flow_definition_service_js__rspack_import_15/* .toFlowSettings */.RK)(planned.flow), user).catch((error)=>step.blockers.push((0,_flow_engine_flow_errors_js__rspack_import_9/* .errorRef */.O$)(error)));
+            const dependsOnImport = schemaChanges || (0,_definition_bundle_diff_js__rspack_import_11/* .calledFlowSlugs */.Q5)(planned.flow.nodes).some((slug)=>importedSlugs.has(slug));
             if (dependsOnImport) {
-                step.warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.FLOWS_CHECKED_ON_APPLY */.iX.FLOWS_CHECKED_ON_APPLY));
+                step.warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOWS_CHECKED_ON_APPLY */.iX.FLOWS_CHECKED_ON_APPLY));
             } else if (!step.blockers.length) {
-                const { errors, warnings } = await this.flows.validate((0,_flow_definition_service_js__rspack_import_13/* .toFlowSettings */.RK)(planned.flow));
+                const { errors, warnings } = await this.flows.validate((0,_flow_definition_service_js__rspack_import_15/* .toFlowSettings */.RK)(planned.flow));
                 step.blockers.push(...errors);
                 step.warnings.push(...warnings);
             }
             steps.push(step);
         }
-        const checksum = (0,_definition_bundle_diff_js__rspack_import_10/* .bundleChecksum */.i9)(bundle);
+        await this.addPermissionWarnings(steps, savedFlows);
+        const checksum = (0,_definition_bundle_diff_js__rspack_import_11/* .bundleChecksum */.i9)(bundle);
         const plan = {
             checksum,
-            planChecksum: planChecksum(checksum, dto.deprecateMissingFields === true, steps),
+            planChecksum: planChecksum(checksum, {
+                deprecateMissingFields: dto.deprecateMissingFields === true,
+                deactivateMissingFlows: dto.deactivateMissingFlows === true
+            }, steps),
             steps,
             unchanged: {
                 entities: entityDiff.unchangedEntities,
@@ -1325,6 +1513,44 @@ class DefinitionBundleService {
             flows: flowDiff.planned
         };
     }
+    /**
+   * Permissions are IAM data, never promoted: an import only creates the codes of new entities and of
+   * flows that ask for their execute permission, and no role has those here yet. A flow that checks a
+   * code this environment does not have (and the import does not create) refuses every caller there.
+   */ async addPermissionWarnings(steps, savedFlows) {
+        if (!this.actionRegistry?.findMissingCodes) return;
+        const createdBy = new Map();
+        for (const step of steps.filter((s)=>s.kind === 'create_entity'))for (const code of (0,_entity_permission_service_js__rspack_import_14/* .entityPermissionCodes */.Z)(step.entityCode))createdBy.set(code, step);
+        for (const [step, flow] of savedFlows)if ((0,_flow_engine_flow_types_js__rspack_import_10/* .flowEndpoints */.Xr)(flow).some(_flow_definition_service_js__rspack_import_15/* .asksExecutePermission */.b$)) createdBy.set((0,_flow_definition_service_js__rspack_import_15/* .defaultFlowPermissionCode */.Er)(flow.slug), step);
+        const checked = savedFlows.map(([step, flow])=>[
+                step,
+                (0,_definition_bundle_diff_js__rspack_import_11/* .permissionCodes */.QJ)(flow).filter((code)=>!code.includes('*'))
+            ]);
+        const asked = [
+            ...new Set([
+                ...createdBy.keys(),
+                ...checked.flatMap(([, codes])=>codes)
+            ])
+        ];
+        if (!asked.length) return;
+        const missing = new Set(await this.actionRegistry.findMissingCodes(asked));
+        const ungranted = new Map();
+        for (const [code, step] of createdBy)if (missing.has(code)) ungranted.set(step, [
+            ...ungranted.get(step) ?? [],
+            code
+        ]);
+        for (const [step, codes] of ungranted)step.warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.PERMISSIONS_TO_GRANT */.iX.PERMISSIONS_TO_GRANT, {
+            subject: (0,_definition_bundle_diff_js__rspack_import_11/* .bundleSubject */.bs)(step),
+            codes: codes.join(', ')
+        }));
+        for (const [step, codes] of checked){
+            const unknown = codes.filter((code)=>missing.has(code) && !createdBy.has(code));
+            if (unknown.length) step.warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOW_PERMISSION_UNKNOWN */.iX.FLOW_PERMISSION_UNKNOWN, {
+                flow: step.flowSlug,
+                codes: unknown.join(', ')
+            }));
+        }
+    }
     /** A relation to an entity this import creates: its id is only known once the entity exists. */ relationNotYetCreated(operation, existingCodes) {
         const target = operation.field?.relationTarget ?? operation.changes?.['relationTarget'];
         return !!target && !existingCodes.has(target);
@@ -1333,25 +1559,15 @@ class DefinitionBundleService {
         if (operation.kind === 'create_entity') return this.schemaSync.planCreateEntity(this.createRequest(operation.entity), user);
         return this.evolution.plan(this.changeRequest(operation, current), user);
     }
-    async diffFlows(bundleFlows) {
-        const repo = await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G);
+    async diffFlows(bundleFlows, options) {
+        const repo = await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_8/* .FlowDefinition */.G);
         const existing = await repo.find();
         const bySlug = new Map(existing.map((flow)=>[
                 flow.slug,
                 flow
             ]));
         const slugs = bundleFlows.map((f)=>f.slug);
-        const deleted = slugs.length ? new Set((await repo.find({
-            select: {
-                id: true,
-                slug: true
-            },
-            where: {
-                slug: (0,typeorm__rspack_import_3.In)(slugs)
-            },
-            withDeleted: true
-        })).filter((f)=>!bySlug.has(f.slug)).map((f)=>f.slug)) : new Set();
-        const variables = this.variables();
+        const variables = this.config.getBundleVariables();
         const result = {
             planned: [],
             unchanged: 0,
@@ -1360,31 +1576,34 @@ class DefinitionBundleService {
         };
         const seen = new Set();
         for (const slug of slugs){
-            if (seen.has(slug)) result.blockers.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.DUPLICATE_FLOW */.iX.DUPLICATE_FLOW, {
+            if (seen.has(slug)) result.blockers.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.DUPLICATE_FLOW */.iX.DUPLICATE_FLOW, {
                 flow: slug
             }));
             seen.add(slug);
         }
-        for (const bundleFlow of (0,_definition_bundle_diff_js__rspack_import_10/* .orderFlows */.qG)(bundleFlows)){
-            const { nodes, missing } = (0,_definition_bundle_diff_js__rspack_import_10/* .applyVariables */.gT)(bundleFlow.nodes ?? [], variables);
+        for (const bundleFlow of (0,_definition_bundle_diff_js__rspack_import_11/* .orderFlows */.qG)(bundleFlows)){
+            const { nodes, missing } = (0,_definition_bundle_diff_js__rspack_import_11/* .applyVariables */.gT)(bundleFlow.nodes ?? [], variables);
             const flow = {
                 ...bundleFlow,
                 nodes,
                 edges: bundleFlow.edges ?? []
             };
-            const blockers = missing.map((name)=>(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.VARIABLE_MISSING */.iX.VARIABLE_MISSING, {
+            const blockers = missing.map((name)=>(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.VARIABLE_MISSING */.iX.VARIABLE_MISSING, {
                     name,
                     flow: flow.slug
                 }));
             const target = bySlug.get(flow.slug);
-            if (!target && deleted.has(flow.slug)) blockers.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.FLOW_SLUG_DELETED */.iX.FLOW_SLUG_DELETED, {
-                flow: flow.slug
-            }));
             const keys = storedApiKeys(target);
-            const warnings = flow.nodes.filter((node)=>needsApiKey(node) && !keys.has(node.id)).map((node)=>(0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.FLOW_API_KEY_GENERATED */.iX.FLOW_API_KEY_GENERATED, {
+            const warnings = flow.nodes.filter((node)=>needsApiKey(node) && !keys.has(node.id)).map((node)=>(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOW_API_KEY_GENERATED */.iX.FLOW_API_KEY_GENERATED, {
                     flow: flow.slug,
-                    path: triggerPath(node) ?? ''
+                    path: (0,_flow_engine_flow_types_js__rspack_import_10/* .triggerPath */.um)(node) ?? ''
                 }));
+            // Read before the variables are filled in: an id this environment provides through `${var:NAME}` is not fixed.
+            const ids = (0,_definition_bundle_diff_js__rspack_import_11/* .fixedIds */.f7)(bundleFlow.nodes ?? []);
+            if (ids.length) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOW_FIXED_IDS */.iX.FLOW_FIXED_IDS, {
+                flow: flow.slug,
+                ids: ids.join(', ')
+            }));
             if (!target) {
                 result.planned.push({
                     kind: 'create_flow',
@@ -1396,13 +1615,13 @@ class DefinitionBundleService {
                 });
                 continue;
             }
-            const live = (0,_flow_definition_service_js__rspack_import_13/* .snapshotOf */.eY)(target);
-            const changed = _interfaces_flow_definition_interface_js__rspack_import_19/* .FLOW_VERSIONED_FIELDS.filter */.v.filter((key)=>key === 'nodes' ? (0,_definition_bundle_diff_js__rspack_import_10/* .canonicalJson */.dj)((0,_definition_bundle_diff_js__rspack_import_10/* .stripApiKeys */.dX)(live.nodes ?? [])) !== (0,_definition_bundle_diff_js__rspack_import_10/* .canonicalJson */.dj)((0,_definition_bundle_diff_js__rspack_import_10/* .stripApiKeys */.dX)(flow.nodes)) : (0,_definition_bundle_diff_js__rspack_import_10/* .canonicalJson */.dj)(live[key] ?? null) !== (0,_definition_bundle_diff_js__rspack_import_10/* .canonicalJson */.dj)(flow[key] ?? null));
-            if (!changed.length && (0,_flow_definition_service_js__rspack_import_13/* .isPublished */.HF)(target) && !blockers.length) {
+            const live = (0,_flow_definition_service_js__rspack_import_15/* .snapshotOf */.eY)(target);
+            const changed = _interfaces_flow_definition_interface_js__rspack_import_23/* .FLOW_VERSIONED_FIELDS.filter */.v.filter((key)=>key === 'nodes' ? (0,_definition_bundle_diff_js__rspack_import_11/* .canonicalJson */.dj)((0,_definition_bundle_diff_js__rspack_import_11/* .stripApiKeys */.dX)(live.nodes ?? [])) !== (0,_definition_bundle_diff_js__rspack_import_11/* .canonicalJson */.dj)((0,_definition_bundle_diff_js__rspack_import_11/* .stripApiKeys */.dX)(flow.nodes)) : (0,_definition_bundle_diff_js__rspack_import_11/* .canonicalJson */.dj)(live[key] ?? null) !== (0,_definition_bundle_diff_js__rspack_import_11/* .canonicalJson */.dj)(flow[key] ?? null));
+            if (!changed.length && (0,_flow_definition_service_js__rspack_import_15/* .isPublished */.HF)(target) && !blockers.length) {
                 result.unchanged++;
                 continue;
             }
-            if (target.draft) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.FLOW_DRAFT_REPLACED */.iX.FLOW_DRAFT_REPLACED, {
+            if (target.draft) warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOW_DRAFT_REPLACED */.iX.FLOW_DRAFT_REPLACED, {
                 flow: flow.slug
             }));
             result.planned.push({
@@ -1416,10 +1635,38 @@ class DefinitionBundleService {
                 blockers
             });
         }
-        for (const extra of existing.filter((flow)=>!seen.has(flow.slug)))result.extras.push({
+        const missing = existing.filter((flow)=>!seen.has(flow.slug));
+        const deactivated = options.deactivateMissingFlows ? missing.filter((flow)=>flow.isActive && (0,_flow_definition_service_js__rspack_import_15/* .isPublished */.HF)(flow)) : [];
+        for (const extra of missing.filter((flow)=>!deactivated.includes(flow)))result.extras.push({
             kind: 'flow',
             flowSlug: extra.slug
         });
+        // Callers first: a flow is switched off only once the live flows that call it are.
+        for (const live of (0,_definition_bundle_diff_js__rspack_import_11/* .orderFlows */.qG)(deactivated.map((flow)=>(0,_flow_definition_service_js__rspack_import_15/* .snapshotOf */.eY)(flow))).toReversed()){
+            const target = bySlug.get(live.slug);
+            const callers = bundleFlows.filter((flow)=>flow.isActive && (0,_definition_bundle_diff_js__rspack_import_11/* .calledFlowSlugs */.Q5)(flow.nodes ?? []).includes(live.slug)).map((flow)=>flow.slug);
+            result.planned.push({
+                kind: 'deactivate_flow',
+                flow: live,
+                existingId: target.id,
+                details: {
+                    changes: [
+                        'isActive'
+                    ]
+                },
+                warnings: target.draft ? [
+                    (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOW_DRAFT_REPLACED */.iX.FLOW_DRAFT_REPLACED, {
+                        flow: live.slug
+                    })
+                ] : [],
+                blockers: callers.length ? [
+                    (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.FLOW_DEACTIVATE_CALLED */.iX.FLOW_DEACTIVATE_CALLED, {
+                        flow: live.slug,
+                        callers: callers.toSorted(_definition_bundle_diff_js__rspack_import_11/* .byCode */.VU).join(', ')
+                    })
+                ] : []
+            });
+        }
         return result;
     }
     // ── requests for the designer's services ────────────────────────────────────────────
@@ -1459,7 +1706,7 @@ class DefinitionBundleService {
         switch(operation.kind){
             case 'add_field':
                 return {
-                    action: _dtos_schema_change_dto_js__rspack_import_4/* .SchemaChangeAction.ADD_FIELD */.M3.ADD_FIELD,
+                    action: _dtos_schema_change_dto_js__rspack_import_5/* .SchemaChangeAction.ADD_FIELD */.M3.ADD_FIELD,
                     entityDefinitionId: entity?.id,
                     field: this.fieldSpec(operation.field, idOf(operation.field.relationTarget))
                 };
@@ -1471,24 +1718,24 @@ class DefinitionBundleService {
                         relationTargetEntityId: idOf(relationTarget) ?? null
                     });
                     return {
-                        action: _dtos_schema_change_dto_js__rspack_import_4/* .SchemaChangeAction.UPDATE_FIELD */.M3.UPDATE_FIELD,
+                        action: _dtos_schema_change_dto_js__rspack_import_5/* .SchemaChangeAction.UPDATE_FIELD */.M3.UPDATE_FIELD,
                         fieldDefinitionId: operation.targetFieldId,
                         changes
                     };
                 }
             case 'deprecate_field':
                 return {
-                    action: _dtos_schema_change_dto_js__rspack_import_4/* .SchemaChangeAction.DEPRECATE_FIELD */.M3.DEPRECATE_FIELD,
+                    action: _dtos_schema_change_dto_js__rspack_import_5/* .SchemaChangeAction.DEPRECATE_FIELD */.M3.DEPRECATE_FIELD,
                     fieldDefinitionId: operation.targetFieldId
                 };
             case 'restore_field':
                 return {
-                    action: _dtos_schema_change_dto_js__rspack_import_4/* .SchemaChangeAction.RESTORE_FIELD */.M3.RESTORE_FIELD,
+                    action: _dtos_schema_change_dto_js__rspack_import_5/* .SchemaChangeAction.RESTORE_FIELD */.M3.RESTORE_FIELD,
                     fieldDefinitionId: operation.targetFieldId
                 };
             default:
                 return {
-                    action: _dtos_schema_change_dto_js__rspack_import_4/* .SchemaChangeAction.UPDATE_ENTITY */.M3.UPDATE_ENTITY,
+                    action: _dtos_schema_change_dto_js__rspack_import_5/* .SchemaChangeAction.UPDATE_ENTITY */.M3.UPDATE_ENTITY,
                     entityDefinitionId: entity?.id,
                     changes: operation.changes
                 };
@@ -1496,21 +1743,44 @@ class DefinitionBundleService {
     }
     // ── apply ───────────────────────────────────────────────────────────────────────────
     async applyImport(dto, user) {
-        const checksum = (0,_definition_bundle_diff_js__rspack_import_10/* .bundleChecksum */.i9)(dto.bundle);
+        const checksum = (0,_definition_bundle_diff_js__rspack_import_11/* .bundleChecksum */.i9)(dto.bundle);
         if (dto.expectedChecksum && dto.expectedChecksum !== checksum) {
-            throw new _nestjs_common__rspack_import_1.ConflictException({
+            throw new _nestjs_common__rspack_import_2.ConflictException({
                 message: 'The bundle is not the one that was reviewed. Plan the import again.',
-                messageKey: _config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.CHECKSUM_MISMATCH */.iX.CHECKSUM_MISMATCH,
+                messageKey: _config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.CHECKSUM_MISMATCH */.iX.CHECKSUM_MISMATCH,
                 messageVariables: {
                     checksum
                 }
             });
         }
+        return this.withImportLock(()=>this.runImport(dto, user));
+    }
+    /** Held on a connection of its own for the whole import (plan and every step), released before that connection goes back to the pool. */ async withImportLock(fn) {
+        const driver = await this.provider.getDriver();
+        const qr = await this.provider.getQueryRunner();
+        try {
+            await qr.connect();
+            if (!await this.dialect.tryAcquireSessionLock(qr, IMPORT_LOCK, driver)) {
+                throw new _nestjs_common__rspack_import_2.ConflictException({
+                    message: 'Another import is running in this environment. Try again when it has finished.',
+                    messageKey: _config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.IMPORT_IN_PROGRESS */.iX.IMPORT_IN_PROGRESS
+                });
+            }
+            try {
+                return await fn();
+            } finally{
+                await this.dialect.releaseSessionLock(qr, IMPORT_LOCK, driver).catch(()=>undefined);
+            }
+        } finally{
+            await qr.release().catch(()=>undefined);
+        }
+    }
+    async runImport(dto, user) {
         const { plan, operations, flows } = await this.buildPlan(dto, user);
         if (dto.expectedPlanChecksum && dto.expectedPlanChecksum !== plan.planChecksum) {
-            throw new _nestjs_common__rspack_import_1.ConflictException({
+            throw new _nestjs_common__rspack_import_2.ConflictException({
                 message: 'The plan changed since it was reviewed. Plan the import again.',
-                messageKey: _config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.PLAN_CHANGED */.iX.PLAN_CHANGED,
+                messageKey: _config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.PLAN_CHANGED */.iX.PLAN_CHANGED,
                 messageVariables: {
                     planChecksum: plan.planChecksum
                 }
@@ -1523,33 +1793,33 @@ class DefinitionBundleService {
                     ...b
                 })),
             ...plan.steps.flatMap((s)=>s.blockers.map((b)=>({
-                        field: (0,_definition_bundle_diff_js__rspack_import_10/* .bundleSubject */.bs)(s),
+                        field: (0,_definition_bundle_diff_js__rspack_import_11/* .bundleSubject */.bs)(s),
                         ...b
                     })))
         ];
         if (blockers.length) {
-            throw new _nestjs_common__rspack_import_1.ConflictException({
+            throw new _nestjs_common__rspack_import_2.ConflictException({
                 message: 'The import is blocked. Plan it again to see why.',
-                messageKey: _config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.APPLY_BLOCKED */.iX.APPLY_BLOCKED,
+                messageKey: _config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.APPLY_BLOCKED */.iX.APPLY_BLOCKED,
                 errors: blockers
             });
         }
         if (plan.mayLoseData && dto.confirm !== true) {
             const lossy = plan.steps.filter((s)=>s.preview?.destructive || !s.preview && mayLoseData(s)).map((s)=>({
-                    field: (0,_definition_bundle_diff_js__rspack_import_10/* .bundleSubject */.bs)(s),
-                    messageKey: _config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.CONFIRM_REQUIRED */.iX.CONFIRM_REQUIRED
+                    field: (0,_definition_bundle_diff_js__rspack_import_11/* .bundleSubject */.bs)(s),
+                    messageKey: _config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.CONFIRM_REQUIRED */.iX.CONFIRM_REQUIRED
                 }));
-            throw new _nestjs_common__rspack_import_1.BadRequestException({
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: 'The import loses data or information. Review the plan and resend with confirm: true.',
-                messageKey: _config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.CONFIRM_REQUIRED */.iX.CONFIRM_REQUIRED,
+                messageKey: _config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.CONFIRM_REQUIRED */.iX.CONFIRM_REQUIRED,
                 errors: lossy
             });
         }
         // A confirmation covers the steps that were reviewed, never ones the environment has grown since.
         if (plan.mayLoseData && !dto.expectedPlanChecksum) {
-            throw new _nestjs_common__rspack_import_1.BadRequestException({
+            throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: 'Send the planChecksum of the reviewed plan as expectedPlanChecksum to confirm it.',
-                messageKey: _config_message_keys_js__rspack_import_17/* .BUNDLE_MESSAGES.PLAN_CHECKSUM_REQUIRED */.iX.PLAN_CHECKSUM_REQUIRED
+                messageKey: _config_message_keys_js__rspack_import_20/* .BUNDLE_MESSAGES.PLAN_CHECKSUM_REQUIRED */.iX.PLAN_CHECKSUM_REQUIRED
             });
         }
         const result = {
@@ -1577,7 +1847,7 @@ class DefinitionBundleService {
                 result.steps.push({
                     ...step,
                     status: 'failed',
-                    error: (0,_flow_engine_flow_errors_js__rspack_import_8/* .errorRef */.O$)(error),
+                    error: (0,_flow_engine_flow_errors_js__rspack_import_9/* .errorRef */.O$)(error),
                     ...reasons.length ? {
                         blockers: reasons
                     } : {}
@@ -1608,7 +1878,7 @@ class DefinitionBundleService {
         if (operation.kind === 'create_entity') {
             const entity = operation.entity;
             await this.schemaSync.createEntity(this.createRequest(entity), user, {
-                entityId: await this.idIsFree(_entities_entity_definition_entity_js__rspack_import_5/* .EntityDefinition */.f, entity.id) ? entity.id : undefined,
+                entityId: await this.idIsFree(_entities_entity_definition_entity_js__rspack_import_6/* .EntityDefinition */.f, entity.id) ? entity.id : undefined,
                 fieldIds: Object.fromEntries(await this.freeFieldIds(entity.fields))
             });
             return;
@@ -1617,7 +1887,7 @@ class DefinitionBundleService {
             ...this.changeRequest(operation, current),
             confirm
         };
-        const fieldId = operation.kind === 'add_field' && await this.idIsFree(_entities_field_definition_entity_js__rspack_import_6/* .FieldDefinition */.c, operation.field.id) ? operation.field.id : undefined;
+        const fieldId = operation.kind === 'add_field' && await this.idIsFree(_entities_field_definition_entity_js__rspack_import_7/* .FieldDefinition */.c, operation.field.id) ? operation.field.id : undefined;
         await this.evolution.apply(request, user, {
             fieldId
         });
@@ -1632,12 +1902,12 @@ class DefinitionBundleService {
     }
     async freeFieldIds(fields) {
         if (!fields.length) return [];
-        const taken = new Set((await (await this.provider.getRepository(_entities_field_definition_entity_js__rspack_import_6/* .FieldDefinition */.c)).find({
+        const taken = new Set((await (await this.provider.getRepository(_entities_field_definition_entity_js__rspack_import_7/* .FieldDefinition */.c)).find({
             select: {
                 id: true
             },
             where: {
-                id: (0,typeorm__rspack_import_3.In)(fields.map((f)=>f.id))
+                id: (0,typeorm__rspack_import_4.In)(fields.map((f)=>f.id))
             },
             withDeleted: true
         })).map((f)=>f.id));
@@ -1647,6 +1917,7 @@ class DefinitionBundleService {
             ]);
     }
     /** Saves the flow (a Request step keeps this environment's API key, or gets a new one shown once) and publishes it. */ async applyFlowStep(planned, note, apiKeys, user) {
+        if (planned.kind === 'deactivate_flow') return this.deactivateFlow(planned.existingId, note, user);
         const existing = planned.existingId ? await this.flows.findOrFail(planned.existingId) : undefined;
         const keys = storedApiKeys(existing);
         const generated = [];
@@ -1664,7 +1935,7 @@ class DefinitionBundleService {
             generated.push({
                 flowSlug: planned.flow.slug,
                 nodeId: node.id,
-                path: triggerPath(node),
+                path: (0,_flow_engine_flow_types_js__rspack_import_10/* .triggerPath */.um)(node),
                 key
             });
             return {
@@ -1688,23 +1959,38 @@ class DefinitionBundleService {
         apiKeys.push(...generated);
         await this.flows.publish(id, note, user);
     }
+    /** Publishes the live flow switched off; an unpublished draft is replaced, never published along with it. */ async deactivateFlow(id, note, user) {
+        const live = (0,_flow_definition_service_js__rspack_import_15/* .snapshotOf */.eY)(await this.flows.findOrFail(id));
+        await this.flows.update({
+            ...live,
+            description: live.description ?? undefined,
+            isActive: false,
+            id
+        }, user);
+        await this.flows.publish(id, note, user);
+    }
 }
 DefinitionBundleService = _ts_decorate([
-    (0,_nestjs_common__rspack_import_1.Injectable)({
-        scope: _nestjs_common__rspack_import_1.Scope.REQUEST
+    (0,_nestjs_common__rspack_import_2.Injectable)({
+        scope: _nestjs_common__rspack_import_2.Scope.REQUEST
     }),
-    _ts_param(0, (0,_nestjs_common__rspack_import_1.Inject)(_entity_builder_datasource_provider_js__rspack_import_12/* .EntityBuilderDataSourceProvider */.D)),
-    _ts_param(1, (0,_nestjs_common__rspack_import_1.Inject)(_entity_builder_config_service_js__rspack_import_11/* .EntityBuilderConfigService */.E)),
-    _ts_param(2, (0,_nestjs_common__rspack_import_1.Inject)(_schema_sync_service_js__rspack_import_15/* .SchemaSyncService */.W)),
-    _ts_param(3, (0,_nestjs_common__rspack_import_1.Inject)(_schema_evolution_service_js__rspack_import_14/* .SchemaEvolutionService */._)),
-    _ts_param(4, (0,_nestjs_common__rspack_import_1.Inject)(_flow_definition_service_js__rspack_import_13/* .FlowDefinitionService */.Tk)),
+    _ts_param(0, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_datasource_provider_js__rspack_import_13/* .EntityBuilderDataSourceProvider */.D)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_config_service_js__rspack_import_12/* .EntityBuilderConfigService */.E)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_2.Inject)(_schema_sync_service_js__rspack_import_18/* .SchemaSyncService */.W)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_2.Inject)(_schema_evolution_service_js__rspack_import_17/* .SchemaEvolutionService */._)),
+    _ts_param(4, (0,_nestjs_common__rspack_import_2.Inject)(_flow_definition_service_js__rspack_import_15/* .FlowDefinitionService */.Tk)),
+    _ts_param(5, (0,_nestjs_common__rspack_import_2.Inject)(_schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I)),
+    _ts_param(6, (0,_nestjs_common__rspack_import_2.Optional)()),
+    _ts_param(6, (0,_nestjs_common__rspack_import_2.Inject)(_flusys_nestjs_shared_interfaces__rspack_import_0.PERMISSION_ACTION_REGISTRY)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        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_config_service_js__rspack_import_11/* .EntityBuilderConfigService */.E === "undefined" ? Object : _entity_builder_config_service_js__rspack_import_11/* .EntityBuilderConfigService */.E,
-        typeof _schema_sync_service_js__rspack_import_15/* .SchemaSyncService */.W === "undefined" ? Object : _schema_sync_service_js__rspack_import_15/* .SchemaSyncService */.W,
-        typeof _schema_evolution_service_js__rspack_import_14/* .SchemaEvolutionService */._ === "undefined" ? Object : _schema_evolution_service_js__rspack_import_14/* .SchemaEvolutionService */._,
-        typeof _flow_definition_service_js__rspack_import_13/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_13/* .FlowDefinitionService */.Tk
+        typeof _entity_builder_datasource_provider_js__rspack_import_13/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_13/* .EntityBuilderDataSourceProvider */.D,
+        typeof _entity_builder_config_service_js__rspack_import_12/* .EntityBuilderConfigService */.E === "undefined" ? Object : _entity_builder_config_service_js__rspack_import_12/* .EntityBuilderConfigService */.E,
+        typeof _schema_sync_service_js__rspack_import_18/* .SchemaSyncService */.W === "undefined" ? Object : _schema_sync_service_js__rspack_import_18/* .SchemaSyncService */.W,
+        typeof _schema_evolution_service_js__rspack_import_17/* .SchemaEvolutionService */._ === "undefined" ? Object : _schema_evolution_service_js__rspack_import_17/* .SchemaEvolutionService */._,
+        typeof _flow_definition_service_js__rspack_import_15/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_15/* .FlowDefinitionService */.Tk,
+        typeof _schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I,
+        typeof IPermissionActionRegistry === "undefined" ? Object : IPermissionActionRegistry
     ])
 ], DefinitionBundleService);
 
@@ -1746,7 +2032,7 @@ function _ts_param(paramIndex, decorator) {
 
 
 
-/** Every cached definition list/get. Schema changes write these rows inside a transaction, past the cached services. */ const CACHED_DEFINITIONS = [
+/** Every cached definition list/get. Schema changes write these rows inside a transaction, past the cached services, so they are bumped after it commits. */ const CACHED_DEFINITIONS = [
     _config_event_actions_js__rspack_import_3/* .ENTITY_BUILDER_EVENT_ENTITIES.ENTITY_DEFINITION */.P.ENTITY_DEFINITION,
     _config_event_actions_js__rspack_import_3/* .ENTITY_BUILDER_EVENT_ENTITIES.FIELD_DEFINITION */.P.FIELD_DEFINITION,
     _config_event_actions_js__rspack_import_3/* .ENTITY_BUILDER_EVENT_ENTITIES.FLOW_DEFINITION */.P.FLOW_DEFINITION
@@ -1759,7 +2045,7 @@ class DefinitionCacheService {
         this.utilsService = utilsService;
     }
     /** `tenantId` is the tenant whose definitions changed (see `cacheTenantId`); caches are keyed per tenant. */ async clearAll(tenantId) {
-        await Promise.all(CACHED_DEFINITIONS.map((name)=>this.utilsService.clearCache(name, this.cacheManager, undefined, tenantId)));
+        await Promise.all(CACHED_DEFINITIONS.map((name)=>this.utilsService.clearCache(name, this.cacheManager, tenantId)));
     }
 }
 DefinitionCacheService = _ts_decorate([
@@ -1885,11 +2171,10 @@ const DEFAULT_ENDPOINT_NAME = {
     delete: 'Delete'
 };
 const DEFAULT_INPUT_LABEL = {
-    id: 'Id',
-    ids: 'Ids',
-    search: 'Search'
+    id: 'Id'
 };
 const DEFAULT_NO_MATCH_MESSAGE = 'No record matches the filter.';
+const DEFAULT_DELETE_ONLY_MESSAGE = 'Only delete is supported: a flow cannot restore or permanently delete a record.';
 const MAX_NAME_LENGTH = 255;
 /** A supplied text when it has content, the English default otherwise. */ const textOr = (value, fallback)=>value?.trim() || fallback;
 const INPUT_TYPE = {
@@ -1907,7 +2192,18 @@ const INPUT_TYPE = {
     [_enums_field_type_enum_js__rspack_import_2/* .FieldType.JSON */.P.JSON]: 'object',
     [_enums_field_type_enum_js__rspack_import_2/* .FieldType.FILE */.P.FILE]: 'uuid'
 };
-const LIST_LIMIT = 50;
+/** The API controller endpoint each endpoint's Request step stands in for. */ const ENDPOINT_CONTRACTS = {
+    insert: 'insert',
+    insertMany: 'insert_many',
+    getById: 'get_by_id',
+    getByIds: 'get_by_ids',
+    getAll: 'get_all',
+    getByFilter: 'get_by_filter',
+    update: 'update',
+    updateMany: 'update_many',
+    bulkUpsert: 'bulk_upsert',
+    delete: 'delete'
+};
 const READ_ENDPOINTS = new Set([
     'getById',
     'getByIds',
@@ -1967,10 +2263,6 @@ const ref = (path)=>({
         type: 'field_ref',
         ref: path
     });
-const lit = (value)=>({
-        type: 'literal',
-        value
-    });
 /** `customer_ticket` -> `customer-ticket`: an entity code always fits a flow URL name. */ const entityFlowSlug = (entityCode)=>entityCode.replace(/_/g, '-');
 function optionValues(options) {
     return (options ?? []).map((o)=>o && typeof o === 'object' && 'value' in o ? String(o.value) : String(o));
@@ -2041,38 +2333,38 @@ const optionalFieldInputs = (fields)=>fields.map((f)=>fieldInput(f, false));
 const idInput = (t)=>({
         name: 'id',
         label: t.inputLabels.id,
-        type: 'uuid',
-        required: true
-    });
-const idsInput = (t)=>({
-        name: 'ids',
-        label: t.inputLabels.ids,
-        type: 'array',
-        itemType: 'uuid',
-        required: true
+        type: 'uuid'
     });
-const respond = (id, column, statusCode, body, row)=>({
+/** An API controller envelope answer: `<entity>.<action>.success` (or the given key), like the generic controller's. */ const respond = (id, column, statusCode, format, message, messageKey, rest = {}, row)=>({
         id,
         type: 'respond',
         column,
         row,
-        config: 'type' in body ? {
-            statusCode,
-            bodyExpression: body
-        } : {
+        config: {
             statusCode,
-            body
+            format,
+            message,
+            messageKey,
+            ...rest
         }
     });
 /**
- * The steps of one endpoint. Its step ids are `<endpoint>_<step>` (`id()`), so the endpoints of one
- * flow never share a step. A bulk body is the list itself (`itemSchema` checks each item), written by
- * one step that walks it (`target: many`, each item read as `loop.item`), all or nothing, and
- * answered with the saved records in order.
+ * The steps of one endpoint, answering the generic API controller's envelope and message keys. Its step
+ * ids are `<endpoint>_<step>` (`id()`), so the endpoints of one flow never share a step. A bulk body is
+ * the list itself (the declared fields check each item), written by one step that walks it (`target:
+ * many`, each item read as `loop.item`), all or nothing, and answered with the saved records in order.
+ * getAll reads the request's filter, sort, paging, select, withDeleted and `?q=` search, getById and
+ * getByIds their select (getByIds answers one page of every match, like the controller); delete takes a list of ids and refuses restore / permanent, which no flow step does.
  */ function endpointGraph(entity, endpoint, texts) {
     const id = (step)=>`${endpoint}_${step}`;
-    const entityCode = entity.code;
-    const single = (inputSchema, step, statusCode = 200)=>({
+    const { code: entityCode, label } = entity;
+    const key = (action)=>`${entityCode}.${action}.success`;
+    const count = (step)=>({
+            messageVariables: {
+                count: ref(`context.${id(step)}.count`)
+            }
+        });
+    const single = (inputSchema, step, message, action, statusCode = 200)=>({
             inputSchema,
             steps: [
                 {
@@ -2080,7 +2372,9 @@ const respond = (id, column, statusCode, body, row)=>({
                     id: id('record'),
                     column: 1
                 },
-                respond(id('respond'), 2, statusCode, ref(`context.${id('record')}`))
+                respond(id('respond'), 2, statusCode, 'single', message, key(action), {
+                    bodyExpression: ref(`context.${id('record')}`)
+                })
             ],
             edges: [
                 [
@@ -2090,8 +2384,7 @@ const respond = (id, column, statusCode, body, row)=>({
                 ]
             ]
         });
-    const bulk = (itemSchema, step, statusCode)=>({
-            bodyType: 'list',
+    const bulk = (itemSchema, step, message, action, statusCode)=>({
             inputSchema: itemSchema,
             steps: [
                 {
@@ -2104,7 +2397,39 @@ const respond = (id, column, statusCode, body, row)=>({
                         items: ref('input')
                     }
                 },
-                respond(id('respond'), 2, statusCode, ref(`context.${id('records')}.items`))
+                respond(id('respond'), 2, statusCode, 'bulk', message, key(action), {
+                    bodyExpression: ref(`context.${id('records')}.items`),
+                    ...count('records')
+                })
+            ],
+            edges: [
+                [
+                    id('records'),
+                    'out',
+                    id('respond')
+                ]
+            ]
+        });
+    const list = (query, message, action, paged = true)=>({
+            inputSchema: [],
+            steps: [
+                {
+                    id: id('records'),
+                    type: 'entity_query',
+                    column: 1,
+                    config: {
+                        entityCode,
+                        ...query
+                    }
+                },
+                respond(id('respond'), 2, 200, 'list', message, key(action), {
+                    bodyExpression: ref(`context.${id('records')}.items`),
+                    ...paged ? {
+                        total: ref(`context.${id('records')}.total`),
+                        page: ref(`context.${id('records')}.page`),
+                        pageSize: ref(`context.${id('records')}.pageSize`)
+                    } : {}
+                })
             ],
             edges: [
                 [
@@ -2124,7 +2449,7 @@ const respond = (id, column, statusCode, body, row)=>({
                     entityCode,
                     fields: fieldMap(entity.fields, 'input')
                 }
-            }, 201);
+            }, `${label} created successfully`, 'create', 201);
         case 'insertMany':
             return bulk(insertInputs, {
                 type: 'entity_insert',
@@ -2132,57 +2457,36 @@ const respond = (id, column, statusCode, body, row)=>({
                     entityCode,
                     fields: fieldMap(entity.fields, 'loop.item')
                 }
-            }, 201);
+            }, `${label} records created successfully`, 'create.many', 201);
         case 'getById':
-            return single([
-                idInput(texts)
-            ], {
+            return single([], {
                 type: 'entity_get',
                 config: {
                     entityCode,
-                    id: ref('input.id')
+                    id: ref('input.id'),
+                    fromRequest: true
                 }
-            });
+            }, `${label} retrieved successfully`, 'get');
         case 'getByIds':
-            return single([
-                idsInput(texts)
-            ], {
-                type: 'entity_query',
-                config: {
-                    entityCode,
-                    filter: {
-                        id: {
-                            op: 'in',
-                            value: ref('input.ids')
-                        }
-                    },
-                    limit: _flow_engine_flow_types_js__rspack_import_1/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT
-                }
-            });
-        case 'getAll':
-            return single([
-                {
-                    name: 'search',
-                    label: texts.inputLabels.search,
-                    type: 'string'
+            return list({
+                filter: {
+                    id: {
+                        op: 'in',
+                        value: ref('input.ids')
+                    }
                 },
-                ...filterInputs(filterFields)
-            ], {
-                type: 'entity_query',
-                config: {
-                    entityCode,
-                    search: ref('input.search'),
-                    filter: fieldMap(filterFields, 'input'),
-                    limit: LIST_LIMIT
-                }
-            });
+                fromRequest: true,
+                limit: _flow_engine_flow_types_js__rspack_import_1/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT
+            }, `${label} records retrieved successfully`, 'get.by.ids', false);
+        case 'getAll':
+            return list({
+                fromRequest: true,
+                limit: _flow_engine_flow_types_js__rspack_import_1/* .FLOW_LIMITS.DEFAULT_QUERY_LIMIT */.Or.DEFAULT_QUERY_LIMIT
+            }, `${label} records retrieved successfully`, 'get.all');
         case 'getByFilter':
             return {
                 inputSchema: [
-                    {
-                        ...idInput(texts),
-                        required: false
-                    },
+                    idInput(texts),
                     ...filterInputs(filterFields)
                 ],
                 steps: [
@@ -2215,12 +2519,10 @@ const respond = (id, column, statusCode, body, row)=>({
                             }
                         }
                     },
-                    respond(id('respond'), 3, 200, ref(`context.${id('records')}.items.0`)),
-                    respond(id('not_found'), 3, 404, {
-                        success: lit(false),
-                        message: lit(texts.noMatchMessage),
-                        messageKey: lit(_config_message_keys_js__rspack_import_4/* .GENERIC_RECORD_MESSAGES.NO_MATCH */.j4.NO_MATCH)
-                    }, 1)
+                    respond(id('respond'), 3, 200, 'single', `${label} retrieved successfully`, key('get.by.filter'), {
+                        bodyExpression: ref(`context.${id('records')}.items.0`)
+                    }),
+                    respond(id('not_found'), 3, 404, 'message', texts.noMatchMessage, _config_message_keys_js__rspack_import_4/* .GENERIC_RECORD_MESSAGES.NO_MATCH */.j4.NO_MATCH, {}, 1)
                 ],
                 edges: [
                     [
@@ -2241,34 +2543,25 @@ const respond = (id, column, statusCode, body, row)=>({
                 ]
             };
         case 'update':
-            return single([
-                idInput(texts),
-                ...optionalFieldInputs(entity.fields)
-            ], {
+            return single(optionalFieldInputs(entity.fields), {
                 type: 'entity_update',
                 config: {
                     entityCode,
                     id: ref('input.id'),
                     fields: fieldMap(entity.fields, 'input')
                 }
-            });
+            }, `${label} updated successfully`, 'update');
         case 'updateMany':
-            return bulk([
-                idInput(texts),
-                ...optionalFieldInputs(entity.fields)
-            ], {
+            return bulk(optionalFieldInputs(entity.fields), {
                 type: 'entity_update',
                 config: {
                     entityCode,
                     fields: fieldMap(entity.fields, 'loop.item')
                 }
-            }, 200);
+            }, `${label} records updated successfully`, 'update.many', 200);
         case 'bulkUpsert':
             return bulk([
-                {
-                    ...idInput(texts),
-                    required: false
-                },
+                idInput(texts),
                 ...optionalFieldInputs(entity.fields)
             ], {
                 type: 'entity_update',
@@ -2277,17 +2570,60 @@ const respond = (id, column, statusCode, body, row)=>({
                     fields: fieldMap(entity.fields, 'loop.item'),
                     onNotFound: 'insert'
                 }
-            }, 200);
+            }, `${label} records upserted successfully`, 'upsert.many', 200);
         case 'delete':
-            return single([
-                idInput(texts)
-            ], {
-                type: 'entity_delete',
-                config: {
-                    entityCode,
-                    id: ref('input.id')
-                }
-            });
+            return {
+                inputSchema: [],
+                steps: [
+                    {
+                        id: id('type'),
+                        type: 'validate',
+                        column: 1,
+                        config: {
+                            checks: [
+                                {
+                                    id: 'type',
+                                    field: 'type',
+                                    message: texts.deleteOnlyMessage,
+                                    rule: {
+                                        operator: 'AND',
+                                        conditions: [
+                                            {
+                                                field: 'input.type',
+                                                comparison: 'equals',
+                                                value: 'delete'
+                                            }
+                                        ]
+                                    }
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        id: id('records'),
+                        type: 'entity_delete',
+                        column: 2,
+                        config: {
+                            entityCode,
+                            target: 'many',
+                            items: ref('input.id')
+                        }
+                    },
+                    respond(id('respond'), 3, 200, 'message', `${label} records deleted successfully`, key('delete'), count('records'))
+                ],
+                edges: [
+                    [
+                        id('type'),
+                        'out',
+                        id('records')
+                    ],
+                    [
+                        id('records'),
+                        'out',
+                        id('respond')
+                    ]
+                ]
+            };
     }
 }
 /**
@@ -2302,11 +2638,10 @@ const respond = (id, column, statusCode, body, row)=>({
  */ function buildEntityFlow(entity, endpoints, texts = {}) {
     const resolved = {
         inputLabels: {
-            id: textOr(texts.inputLabels?.id, DEFAULT_INPUT_LABEL.id),
-            ids: textOr(texts.inputLabels?.ids, DEFAULT_INPUT_LABEL.ids),
-            search: textOr(texts.inputLabels?.search, DEFAULT_INPUT_LABEL.search)
+            id: textOr(texts.inputLabels?.id, DEFAULT_INPUT_LABEL.id)
         },
-        noMatchMessage: textOr(texts.noMatchMessage, DEFAULT_NO_MATCH_MESSAGE)
+        noMatchMessage: textOr(texts.noMatchMessage, DEFAULT_NO_MATCH_MESSAGE),
+        deleteOnlyMessage: textOr(texts.deleteOnlyMessage, DEFAULT_DELETE_ONLY_MESSAGE)
     };
     const nodes = [];
     const edges = [];
@@ -2319,8 +2654,10 @@ const respond = (id, column, statusCode, body, row)=>({
             });
         const config = {
             path: ENTITY_FLOW_PATHS[endpoint],
-            bodyType: graph.bodyType ?? 'object',
-            inputSchema: graph.inputSchema,
+            contract: ENDPOINT_CONTRACTS[endpoint],
+            ...graph.inputSchema.length ? {
+                inputSchema: graph.inputSchema
+            } : {},
             authMode: 'permission',
             permissions: endpointPermissions(entity.code, endpoint),
             ...READ_ENDPOINTS.has(endpoint) ? {} : {
@@ -2405,6 +2742,7 @@ const CRUD_ACTIONS = [
     'update',
     'delete'
 ];
+/** The create / read / update / delete permission codes of a dynamic entity. */ const entityPermissionCodes = (entityCode)=>CRUD_ACTIONS.map((op)=>(0,_flusys_nestjs_shared__rspack_import_0.dynamicEntityPermission)(entityCode, op));
 class EntityPermissionService {
     actionRegistry;
     constructor(actionRegistry){
@@ -2424,7 +2762,7 @@ class EntityPermissionService {
         if (!this.actionRegistry) return;
         await this.actionRegistry.removeActionsByCodes([
             (0,_flusys_nestjs_shared__rspack_import_0.dynamicEntityPermissionParent)(definition.code),
-            ...CRUD_ACTIONS.map((op)=>(0,_flusys_nestjs_shared__rspack_import_0.dynamicEntityPermission)(definition.code, op))
+            ...entityPermissionCodes(definition.code)
         ]);
     }
 }
@@ -2440,6 +2778,8 @@ EntityPermissionService = _ts_decorate([
 
 __webpack_require__.d(__webpack_exports__, {
   u: () => (EntityPermissionService)
+}, {
+  Z: entityPermissionCodes
 });
 
 
@@ -2534,6 +2874,11 @@ const SCALAR_TO_TEXT = new Set([
     _enums_field_type_enum_js__rspack_import_1/* .FieldType.DATETIME */.P.DATETIME
 ]);
 const EMAIL_PG = `'^[^[:space:]@]+@[^[:space:]@]+\\.[^[:space:]@]+$'`;
+const EMAIL_MYSQL = `'^[^ @]+@[^ @]+\\\\.[^ @]+$'`;
+/** Rows whose value is not an email; `castToText` for a column that is not text yet. */ const notEmailCheck = (castToText)=>({
+        description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_EMAIL */.NE.NOT_EMAIL),
+        badRowsWhere: (c, d)=>d === 'postgres' ? `${castToText ? `${c}::text` : c} !~ ${EMAIL_PG}` : `${castToText ? `CAST(${c} AS CHAR)` : c} NOT REGEXP ${EMAIL_MYSQL}`
+    });
 const regexFail = (column, driver, pattern)=>driver === 'postgres' ? `${column} !~ '${pattern}'` : `${column} NOT REGEXP '${pattern}'`;
 const SELECT_KINDS = new Set([
     _enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT,
@@ -2558,17 +2903,12 @@ function planTypeConversion(from, to, driver) {
     if (driver === 'mysql' && (SELECT_KINDS.has(from) && SELECT_KINDS.has(to) || textLike && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN)) return unsupported(from, to);
     // Same physical column (varchar(255)): only the meaning changes.
     if (TEXT_LIKE.has(from) && TEXT_LIKE.has(to)) {
-        const checks = [];
-        if (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL) {
-            checks.push({
-                description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_EMAIL */.NE.NOT_EMAIL),
-                badRowsWhere: (c, d)=>d === 'postgres' ? `${c} !~ ${EMAIL_PG}` : `${c} NOT REGEXP '^[^ @]+@[^ @]+\\\\.[^ @]+$'`
-            });
-        }
         return {
             supported: true,
             noDbChange: true,
-            prechecks: checks
+            prechecks: to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL ? [
+                notEmailCheck(false)
+            ] : []
         };
     }
     if (from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.RELATION */.P.RELATION && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.FILE */.P.FILE || from === _enums_field_type_enum_js__rspack_import_1/* .FieldType.FILE */.P.FILE && to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.RELATION */.P.RELATION) {
@@ -2594,12 +2934,7 @@ function planTypeConversion(from, to, driver) {
                 badRowsWhere: (c, d)=>d === 'postgres' ? `char_length(${c}) > 255` : `CHAR_LENGTH(${c}) > 255`
             }
         ];
-        if (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL) {
-            checks.push({
-                description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_EMAIL */.NE.NOT_EMAIL),
-                badRowsWhere: (c, d)=>d === 'postgres' ? `${c} !~ ${EMAIL_PG}` : `${c} NOT REGEXP '^[^ @]+@[^ @]+\\\\.[^ @]+$'`
-            });
-        }
+        if (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL) checks.push(notEmailCheck(false));
         return {
             supported: true,
             using: (c)=>`${c}::varchar(255)`,
@@ -2608,17 +2943,12 @@ function planTypeConversion(from, to, driver) {
     }
     // scalar -> text-like: always representable
     if (SCALAR_TO_TEXT.has(from) && TEXT_LIKE.has(to)) {
-        const checks = [];
-        if (to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL) {
-            checks.push({
-                description: (0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_2/* .SCHEMA_PRECHECK_MESSAGES.NOT_EMAIL */.NE.NOT_EMAIL),
-                badRowsWhere: (c, d)=>d === 'postgres' ? `${c}::text !~ ${EMAIL_PG}` : `CAST(${c} AS CHAR) NOT REGEXP '^[^ @]+@[^ @]+\\\\.[^ @]+$'`
-            });
-        }
         return {
             supported: true,
             using: (c)=>`${c}::text`,
-            prechecks: checks
+            prechecks: to === _enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL ? [
+                notEmailCheck(true)
+            ] : []
         };
     }
     // text-like / long text -> scalar: every existing value must parse
@@ -2895,10 +3225,44 @@ __webpack_require__.d(__webpack_exports__, {
 }
 
 __webpack_require__.d(__webpack_exports__, {
-  fY: () => (assertIndexableField),
-  kV: () => (assertValidIdentifier)
+  f: () => (assertIndexableField),
+  k: () => (assertValidIdentifier)
+});
+
+
+},
+3086(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/** Pure JSON string helpers for finding and rewriting `<prefix>.<field>` references inside definitions. */ function mapStrings(value, fn) {
+    if (typeof value === 'string') return fn(value);
+    if (Array.isArray(value)) return value.map((v)=>mapStrings(v, fn));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v])=>[
+                k,
+                mapStrings(v, fn)
+            ]));
+    }
+    return value;
+}
+function anyString(value, test) {
+    if (typeof value === 'string') return test(value);
+    if (Array.isArray(value)) return value.some((v)=>anyString(v, test));
+    if (value && typeof value === 'object') return Object.values(value).some((v)=>anyString(v, test));
+    return false;
+}
+const escapeRe = (s)=>s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * `<prefix>.<field>`, `<prefix>.<field>.x` or `{{ <prefix>.<field> }}` inside a template - but not
+ * `<prefix>.<field>_2`. The prefix is a regex source (e.g. `context\.find\.items\.\d+`), captured so a rewrite keeps it.
+ */ const referencePatternSource = (prefixSource, field, flags = '')=>new RegExp(`(^|\\{\\{\\s*)(${prefixSource})\\.${escapeRe(field)}(?!\\w)`, flags);
+const replaceReferenceSource = (s, prefixSource, from, to)=>s.replace(referencePatternSource(prefixSource, from, 'g'), (_match, lead, prefix)=>`${lead}${prefix}.${to}`);
+
+__webpack_require__.d(__webpack_exports__, {
+  gp: () => (anyString),
+  to: () => (mapStrings)
 }, {
-  xJ: RESERVED_WORDS
+  LV: referencePatternSource,
+  NF: escapeRe,
+  Ni: replaceReferenceSource
 });
 
 
@@ -3094,8 +3458,13 @@ class SchemaChangeExecutor {
         ].toSorted().map((code)=>`eb_entity:${code}`);
         const heldLocks = [];
         const qr = await this.dataSourceProvider.getQueryRunner();
-        await qr.connect();
-        await qr.startTransaction();
+        try {
+            await qr.connect();
+            await qr.startTransaction();
+        } catch (error) {
+            await qr.release().catch(()=>undefined);
+            throw (0,_database_error_mapper_js__rspack_import_6/* .mapSchemaError */.i)(error);
+        }
         const state = this.newState(target, options.impact ?? []);
         let committed = false;
         try {
@@ -3139,9 +3508,7 @@ class SchemaChangeExecutor {
             }));
             await qr.commitTransaction();
             committed = true;
-            const entityId = outcome.entityDefinitionId ?? target.entityDefinitionId;
-            if (entityId) this.schemaRegistry.invalidate(entityId);
-            await this.definitionCache.clearAll((0,_flusys_nestjs_shared_utils__rspack_import_0.cacheTenantId)(this.dataSourceProvider));
+            await this.invalidateDefinitions(target, outcome.entityDefinitionId ?? target.entityDefinitionId, state.warnings);
             try {
                 await outcome.afterCommit?.();
             } catch (postCommitError) {
@@ -3158,6 +3525,8 @@ class SchemaChangeExecutor {
         } catch (error) {
             if (!committed) await qr.rollbackTransaction().catch(()=>undefined);
             const undo = !committed && driver === 'mysql' && state.undo.length > 0 ? await this.compensate(qr, target, state) : null;
+            // MySQL commits implicitly at each DDL statement, so metadata written before one may have stayed.
+            if (undo) await this.invalidateDefinitions(target, target.entityDefinitionId, []);
             await this.logFailure(target, error, state.steps, undo);
             throw this.withUndo((0,_database_error_mapper_js__rspack_import_6/* .mapSchemaError */.i)(error), undo);
         } finally{
@@ -3165,6 +3534,17 @@ class SchemaChangeExecutor {
             await qr.release();
         }
     }
+    /** Runs only once the change's transaction has ended: a bump inside it would let a concurrent reader re-cache the old definitions. */ async invalidateDefinitions(target, entityId, warnings) {
+        try {
+            if (entityId) this.schemaRegistry.invalidate(entityId);
+            await this.definitionCache.clearAll((0,_flusys_nestjs_shared_utils__rspack_import_0.cacheTenantId)(this.dataSourceProvider));
+        } catch (cacheError) {
+            this.logger.error(`Clearing the definition cache failed after '${target.action}' on '${target.entityCode}': ${cacheError.message}`);
+            warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_0.messageRef)(_config_message_keys_js__rspack_import_11/* .SCHEMA_WARNING_MESSAGES.FOLLOW_UP_FAILED */.Uu.FOLLOW_UP_FAILED, {
+                detail: (0,_flow_engine_flow_errors_js__rspack_import_3/* .errorRef */.O$)(cacheError)
+            }));
+        }
+    }
     /**
    * MySQL only: runs the reverse of every DDL statement that had run, newest first, still under
    * the entity lock. Stops at the first undo statement that fails - running later ones against an
@@ -3449,14 +3829,14 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var class_transformer__rspack_import_3 = __webpack_require__(5812);
 /* import */ var class_validator__rspack_import_4 = __webpack_require__(5421);
 /* import */ var typeorm__rspack_import_5 = __webpack_require__(7158);
-/* import */ var _config_message_keys_js__rspack_import_19 = __webpack_require__(5732);
+/* import */ var _config_message_keys_js__rspack_import_20 = __webpack_require__(5732);
 /* import */ var _dtos_schema_change_dto_js__rspack_import_6 = __webpack_require__(4945);
 /* import */ var _entities_entity_definition_entity_js__rspack_import_7 = __webpack_require__(3189);
 /* import */ var _entities_field_definition_entity_js__rspack_import_8 = __webpack_require__(2206);
 /* import */ var _entities_schema_change_log_entity_js__rspack_import_9 = __webpack_require__(875);
-/* import */ var _enums_ddl_operation_enum_js__rspack_import_21 = __webpack_require__(9949);
-/* import */ var _enums_entity_status_enum_js__rspack_import_23 = __webpack_require__(1313);
-/* import */ var _enums_field_type_enum_js__rspack_import_20 = __webpack_require__(9614);
+/* import */ var _enums_ddl_operation_enum_js__rspack_import_22 = __webpack_require__(9949);
+/* import */ var _enums_entity_status_enum_js__rspack_import_24 = __webpack_require__(1313);
+/* import */ var _enums_field_type_enum_js__rspack_import_21 = __webpack_require__(9614);
 /* import */ var _entity_builder_datasource_provider_js__rspack_import_10 = __webpack_require__(424);
 /* import */ var _entity_permission_service_js__rspack_import_11 = __webpack_require__(1462);
 /* import */ var _field_value_validator_js__rspack_import_12 = __webpack_require__(3525);
@@ -3464,9 +3844,10 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _identifier_rules_js__rspack_import_14 = __webpack_require__(413);
 /* import */ var _reference_scanner_service_js__rspack_import_15 = __webpack_require__(921);
 /* import */ var _schema_change_executor_service_js__rspack_import_16 = __webpack_require__(6605);
-/* import */ var _schema_change_types_js__rspack_import_22 = __webpack_require__(7827);
+/* import */ var _schema_change_types_js__rspack_import_23 = __webpack_require__(7827);
 /* import */ var _schema_columns_js__rspack_import_17 = __webpack_require__(5313);
-/* import */ var _schema_dialect_adapter_service_js__rspack_import_18 = __webpack_require__(7259);
+/* import */ var _entity_builder_config_service_js__rspack_import_18 = __webpack_require__(4281);
+/* import */ var _schema_dialect_adapter_service_js__rspack_import_19 = __webpack_require__(7259);
 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") {
@@ -3512,48 +3893,59 @@ function _ts_param(paramIndex, decorator) {
 
 
 
+
 
 
 const entityNotFound = (id)=>new _nestjs_common__rspack_import_2.NotFoundException({
         message: `Entity definition '${id}' not found.`,
-        messageKey: _config_message_keys_js__rspack_import_19/* .ENTITY_DEFINITION_MESSAGES.NOT_FOUND */.pL.NOT_FOUND,
+        messageKey: _config_message_keys_js__rspack_import_20/* .ENTITY_DEFINITION_MESSAGES.NOT_FOUND */.pL.NOT_FOUND,
         messageVariables: {
             id
         }
     });
 const fieldNotFound = (id)=>new _nestjs_common__rspack_import_2.NotFoundException({
         message: `Field definition '${id}' not found.`,
-        messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.NOT_FOUND */.oc.NOT_FOUND,
+        messageKey: _config_message_keys_js__rspack_import_20/* .FIELD_DEFINITION_MESSAGES.NOT_FOUND */.oc.NOT_FOUND,
         messageVariables: {
             id
         }
     });
+const HISTORY_LIMIT = 50;
 const DESTRUCTIVE_ACTIONS = [
     _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.DROP_ENTITY */.M3.DROP_ENTITY,
     _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.PURGE_FIELD */.M3.PURGE_FIELD
 ];
 const isDestructiveSchemaAction = (action)=>DESTRUCTIVE_ACTIONS.includes(action);
-const fieldLike = (field)=>({
-        code: field.code,
-        label: field.label ?? field.code,
-        fieldType: field.fieldType,
-        nullable: true,
-        defaultValue: null,
-        selectOptions: field.selectOptions ?? null,
-        validationRules: field.validationRules ?? null
-    });
+/**
+ * Every structural change to an existing entity: add / change / rename / restore / deprecate /
+ * purge a field, change entity settings, drop an entity, and repair drift. Each is a
+ * `SchemaChangeRun` executed by SchemaChangeExecutor, so each can be previewed (`plan`) with
+ * the real SQL and data checks before it is applied. The definitions loaded up front only
+ * validate the request; every run reloads them through its own query runner, so an apply works
+ * on what is current under the entity lock. Plans carry counts but never record values.
+ */ /** Metadata the runtime reads from the cached field list (SchemaRegistryService): changing it must move schemaVersion. */ const FIELD_CACHE_KEYS = new Set([
+    'selectOptions',
+    'validationRules',
+    'defaultValue',
+    'label',
+    'relationTargetEntityId',
+    'isSearchable',
+    'order'
+]);
 class SchemaEvolutionService {
     dataSourceProvider;
     adapter;
     executor;
     references;
     permissions;
-    constructor(dataSourceProvider, adapter, executor, references, permissions){
+    config;
+    constructor(dataSourceProvider, adapter, executor, references, permissions, config){
         this.dataSourceProvider = dataSourceProvider;
         this.adapter = adapter;
         this.executor = executor;
         this.references = references;
         this.permissions = permissions;
+        this.config = config;
     }
     // ── public API ──────────────────────────────────────────────────────────────────────
     async plan(request, user) {
@@ -3575,8 +3967,8 @@ class SchemaEvolutionService {
         const { definition, fields } = await this.loadEntity(entityDefinitionId);
         const driver = await this.dataSourceProvider.getDriver();
         const qr = await this.dataSourceProvider.getQueryRunner();
-        await qr.connect();
         try {
+            await qr.connect();
             const table = await qr.getTable(definition.tableName);
             const findings = this.diff(definition, fields, table ?? undefined, driver);
             let rowCount = null;
@@ -3595,7 +3987,7 @@ class SchemaEvolutionService {
             await qr.release();
         }
     }
-    /** Newest first. Includes failed attempts, with the SQL that was about to run. */ async history(entityDefinitionId, limit = 50) {
+    /** Newest first. Includes failed attempts, with the SQL that was about to run. */ async history(entityDefinitionId) {
         const repo = await this.dataSourceProvider.getRepository(_entities_schema_change_log_entity_js__rspack_import_9/* .SchemaChangeLog */.W);
         return repo.find({
             select: {
@@ -3616,7 +4008,7 @@ class SchemaEvolutionService {
             order: {
                 createdAt: 'DESC'
             },
-            take: Math.min(Math.max(limit, 1), 200)
+            take: HISTORY_LIMIT
         });
     }
     // ── loading ─────────────────────────────────────────────────────────────────────────
@@ -3624,7 +4016,7 @@ class SchemaEvolutionService {
         if (!entityDefinitionId) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: 'entityDefinitionId is required for this action.',
-                messageKey: _config_message_keys_js__rspack_import_19/* .ENTITY_DEFINITION_MESSAGES.ID_REQUIRED */.pL.ID_REQUIRED
+                messageKey: _config_message_keys_js__rspack_import_20/* .ENTITY_DEFINITION_MESSAGES.ID_REQUIRED */.pL.ID_REQUIRED
             });
         }
         return this.definitions((entity)=>this.dataSourceProvider.getRepository(entity), entityDefinitionId);
@@ -3633,7 +4025,7 @@ class SchemaEvolutionService {
         if (!fieldDefinitionId) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: 'fieldDefinitionId is required for this action.',
-                messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.ID_REQUIRED */.oc.ID_REQUIRED
+                messageKey: _config_message_keys_js__rspack_import_20/* .FIELD_DEFINITION_MESSAGES.ID_REQUIRED */.oc.ID_REQUIRED
             });
         }
         const field = await (await this.dataSourceProvider.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c)).findOne({
@@ -3675,7 +4067,7 @@ class SchemaEvolutionService {
         if (unknown.length) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: `Cannot change ${what} property: ${unknown.join(', ')}. Allowed: ${allowed.join(', ')}.`,
-                messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.UNKNOWN_CHANGE_PROPERTY */.Hu.UNKNOWN_CHANGE_PROPERTY,
+                messageKey: _config_message_keys_js__rspack_import_20/* .SCHEMA_MESSAGES.UNKNOWN_CHANGE_PROPERTY */.Hu.UNKNOWN_CHANGE_PROPERTY,
                 messageVariables: {
                     what,
                     properties: unknown.join(', '),
@@ -3692,13 +4084,13 @@ class SchemaEvolutionService {
         const properties = errors.map((e)=>e.property);
         throw new _nestjs_common__rspack_import_2.BadRequestException({
             message: `Invalid value for ${properties.map((p)=>`'${p}'`).join(', ')}.`,
-            messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
+            messageKey: _config_message_keys_js__rspack_import_20/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
             messageVariables: {
                 property: properties.join(', ')
             },
             errors: properties.map((property)=>({
                     field: property,
-                    messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
+                    messageKey: _config_message_keys_js__rspack_import_20/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
                     messageVariables: {
                         property
                     }
@@ -3726,7 +4118,7 @@ class SchemaEvolutionService {
         if (updatedAt && updatedAt.getTime() !== new Date(expected).getTime()) {
             throw new _nestjs_common__rspack_import_2.ConflictException({
                 message: 'Someone else changed this definition since you opened it. Reload it and make your change again.',
-                messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.STALE_DEFINITION */.Hu.STALE_DEFINITION,
+                messageKey: _config_message_keys_js__rspack_import_20/* .SCHEMA_MESSAGES.STALE_DEFINITION */.Hu.STALE_DEFINITION,
                 messageVariables: {
                     updatedAt: updatedAt.toISOString()
                 }
@@ -3735,7 +4127,7 @@ class SchemaEvolutionService {
     }
     /** The field was renamed (or deprecated) by a change that committed after this request was checked. */ changedUnderneath(ctx, before, now) {
         if (now.code === before.code && !!now.deprecatedAt === !!before.deprecatedAt) return false;
-        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DEFINITION_CHANGED */.M3.DEFINITION_CHANGED));
+        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.DEFINITION_CHANGED */.M3.DEFINITION_CHANGED));
         return true;
     }
     // ── dispatch ────────────────────────────────────────────────────────────────────────
@@ -3781,7 +4173,7 @@ class SchemaEvolutionService {
         return (0,_flusys_nestjs_shared_utils__rspack_import_1.withSavepoint)(ctx.qr, ()=>this.scalar(ctx, sql, params)).catch(()=>0);
     }
     paramValue(fieldType, value) {
-        return fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.JSON */.P.JSON || fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT ? JSON.stringify(value) : value;
+        return fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.JSON */.P.JSON || fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT ? JSON.stringify(value) : value;
     }
     notNullSql(ctx, table, column, fieldType, notNull) {
         if (ctx.driver === 'postgres') {
@@ -3789,7 +4181,7 @@ class SchemaEvolutionService {
         }
         return `ALTER TABLE ${ctx.q(table)} MODIFY ${ctx.q(column)} ${(0,_schema_columns_js__rspack_import_17/* .sqlTypeFor */.cg)(fieldType, ctx.driver, this.adapter)} ${notNull ? 'NOT NULL' : 'NULL'}`;
     }
-    /** Makes a column NOT NULL (or nullable again), with the reverse statement for the plan. */ setRequired(ctx, table, column, fieldType, required, step = required ? _config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.MAKE_REQUIRED */.EQ.MAKE_REQUIRED : _config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.MAKE_OPTIONAL */.EQ.MAKE_OPTIONAL) {
+    /** Makes a column NOT NULL (or nullable again), with the reverse statement for the plan. */ setRequired(ctx, table, column, fieldType, required, step = required ? _config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.MAKE_REQUIRED */.EQ.MAKE_REQUIRED : _config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.MAKE_OPTIONAL */.EQ.MAKE_OPTIONAL) {
         return ctx.rawDdl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(step, {
             column
         }), [
@@ -3800,7 +4192,7 @@ class SchemaEvolutionService {
     }
     checkValue(field, value) {
         const { errors } = (0,_field_value_validator_js__rspack_import_12/* .validateRecord */.e)([
-            fieldLike(field)
+            (0,_field_value_validator_js__rspack_import_12/* .valueRulesOf */.C)(field)
         ], {
             [field.code]: value
         }, 'insert');
@@ -3809,7 +4201,7 @@ class SchemaEvolutionService {
     async requireTable(ctx, tableName) {
         const table = await ctx.qr.getTable(tableName);
         if (!table) {
-            ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.TABLE_MISSING */.M3.TABLE_MISSING, {
+            ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.TABLE_MISSING */.M3.TABLE_MISSING, {
                 table: tableName
             }));
         }
@@ -3838,6 +4230,16 @@ class SchemaEvolutionService {
     indexOn(table, column, unique) {
         return table.indices.filter((i)=>i.columnNames.length === 1 && i.columnNames[0] === column && i.isUnique === unique);
     }
+    /** `performance.partialIndexes`: plain indexes of a soft-delete entity cover live rows only (PostgreSQL). */ liveOnly(definition, driver) {
+        return !!this.config?.isPartialIndexesEnabled() && definition.isSoftDeleteEnabled && driver === 'postgres';
+    }
+    /** The plain index on `column` exists with the shape the entity wants (live rows only, or all rows). */ hasPlainIndex(table, column, liveOnly) {
+        return this.indexOn(table, column, false).some((index)=>(0,_schema_columns_js__rspack_import_17/* .isLiveRowsIndex */.YS)(index) === liveOnly);
+    }
+    /** Replaces whatever plain index `column` has with one of the wanted shape. */ async rebuildPlainIndex(ctx, table, tableName, column, liveOnly) {
+        for (const index of this.indexOn(table, column, false))await ctx.qr.dropIndex(table, index);
+        await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(tableName, column, ctx.driver, this.adapter, liveOnly));
+    }
     // ── add_field ───────────────────────────────────────────────────────────────────────
     async prepareAddField(request, user, fieldId) {
         const { definition: loaded } = await this.loadEntity(request.entityDefinitionId);
@@ -3845,11 +4247,11 @@ class SchemaEvolutionService {
         if (!spec) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: "add_field needs a 'field' definition.",
-                messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.DEFINITION_REQUIRED */.oc.DEFINITION_REQUIRED
+                messageKey: _config_message_keys_js__rspack_import_20/* .FIELD_DEFINITION_MESSAGES.DEFINITION_REQUIRED */.oc.DEFINITION_REQUIRED
             });
         }
-        (0,_identifier_rules_js__rspack_import_14/* .assertValidIdentifier */.kV)(spec.code, 'field');
-        (0,_identifier_rules_js__rspack_import_14/* .assertIndexableField */.fY)(spec);
+        (0,_identifier_rules_js__rspack_import_14/* .assertValidIdentifier */.k)(spec.code, 'field');
+        (0,_identifier_rules_js__rspack_import_14/* .assertIndexableField */.f)(spec);
         const lockCodes = await (0,_schema_change_executor_service_js__rspack_import_16/* .relationTargetCodes */.e)(this.dataSourceProvider, [
             spec.relationTargetEntityId
         ]);
@@ -3857,16 +4259,16 @@ class SchemaEvolutionService {
             const { definition, fields } = await this.current(ctx, request, loaded.id);
             const existing = fields.find((f)=>f.code === spec.code);
             if (existing) {
-                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(existing.deprecatedAt ? _config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.FIELD_EXISTS_DEPRECATED */.M3.FIELD_EXISTS_DEPRECATED : _config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.FIELD_EXISTS */.M3.FIELD_EXISTS, {
+                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(existing.deprecatedAt ? _config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.FIELD_EXISTS_DEPRECATED */.M3.FIELD_EXISTS_DEPRECATED : _config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.FIELD_EXISTS */.M3.FIELD_EXISTS, {
                     code: spec.code
                 }));
             }
             const nullable = spec.nullable ?? true;
             const unique = spec.unique ?? false;
             const dbType = this.adapter.mapFieldType(spec.fieldType, ctx.driver);
-            const isRelation = spec.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION;
+            const isRelation = spec.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.RELATION */.P.RELATION;
             if (isRelation && !spec.relationTargetEntityId) {
-                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
+                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
                     field: spec.code
                 }));
             } else if (isRelation) {
@@ -3875,18 +4277,14 @@ class SchemaEvolutionService {
                         id: spec.relationTargetEntityId
                     }
                 });
-                if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_MISSING */.M3.RELATION_TARGET_MISSING));
+                if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_MISSING */.M3.RELATION_TARGET_MISSING));
             }
-            if ((spec.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT || spec.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) && !spec.selectOptions?.length) {
-                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.NO_SELECT_OPTIONS_YET */.Uu.NO_SELECT_OPTIONS_YET));
+            if ((spec.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT || spec.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) && !spec.selectOptions?.length) {
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.NO_SELECT_OPTIONS_YET */.Uu.NO_SELECT_OPTIONS_YET));
             }
             if (spec.defaultValue !== undefined && spec.defaultValue !== null) {
-                const problem = this.checkValue({
-                    ...spec,
-                    code: spec.code,
-                    fieldType: spec.fieldType
-                }, spec.defaultValue);
-                if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
+                const problem = this.checkValue(spec, spec.defaultValue);
+                if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
                     problem
                 }));
             }
@@ -3895,27 +4293,23 @@ class SchemaEvolutionService {
             const backfill = request.backfillValue ?? spec.defaultValue ?? null;
             if (!nullable && rows > 0) {
                 if (backfill === null) {
-                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.REQUIRED_NEEDS_VALUE */.M3.REQUIRED_NEEDS_VALUE, {
+                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.REQUIRED_NEEDS_VALUE */.M3.REQUIRED_NEEDS_VALUE, {
                         count: rows
                     }));
                 } else {
-                    const problem = this.checkValue({
-                        ...spec,
-                        code: spec.code,
-                        fieldType: spec.fieldType
-                    }, backfill);
-                    if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.BACKFILL_INVALID */.M3.BACKFILL_INVALID, {
+                    const problem = this.checkValue(spec, backfill);
+                    if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.BACKFILL_INVALID */.M3.BACKFILL_INVALID, {
                         problem
                     }));
                 }
             }
             // Only a required field is backfilled; every existing row gets the same value, so two rows or more would clash.
             if (unique && !nullable && backfill !== null && rows > 1) {
-                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.UNIQUE_BACKFILL_CONFLICT */.M3.UNIQUE_BACKFILL_CONFLICT));
+                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.UNIQUE_BACKFILL_CONFLICT */.M3.UNIQUE_BACKFILL_CONFLICT));
             }
             if (ctx.blocked || !table) {
                 return {
-                    operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ADD_COLUMN */.i.ADD_COLUMN,
+                    operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.ADD_COLUMN */.i.ADD_COLUMN,
                     diff: {}
                 };
             }
@@ -3929,13 +4323,13 @@ class SchemaEvolutionService {
                 enforceNotNull: false,
                 withUnique: false
             });
-            await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_COLUMN */.EQ.ADD_COLUMN, {
+            await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_COLUMN */.EQ.ADD_COLUMN, {
                 column: spec.code
             }), async ()=>{
                 await ctx.qr.addColumn(table, column);
             });
             if (!nullable && rows > 0) {
-                await ctx.data((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.BACKFILL_EXISTING */.EQ.BACKFILL_EXISTING, {
+                await ctx.data((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.BACKFILL_EXISTING */.EQ.BACKFILL_EXISTING, {
                     count: rows
                 }), `UPDATE ${ctx.q(definition.tableName)} SET ${ctx.q(spec.code)} = ${this.adapter.sqlLiteral(this.paramValue(spec.fieldType, backfill), ctx.driver)}`, async ()=>{
                     await ctx.qr.query((0,_flusys_nestjs_shared_classes__rspack_import_0.buildQuery)(`UPDATE ${ctx.q(definition.tableName)} SET ${ctx.q(spec.code)} = ?`, ctx.driver), [
@@ -3947,17 +4341,17 @@ class SchemaEvolutionService {
                 await this.setRequired(ctx, definition.tableName, spec.code, spec.fieldType, true);
             }
             if (unique) {
-                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_UNIQUE */.EQ.ADD_UNIQUE, {
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_UNIQUE */.EQ.ADD_UNIQUE, {
                     column: spec.code
                 }), async ()=>{
                     await (0,_schema_columns_js__rspack_import_17/* .addUnique */.$6)(ctx.qr, table, spec.code, ctx.driver, this.adapter);
                 });
             }
-            if (spec.isIndexed && !unique) {
-                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
+            if ((0,_schema_columns_js__rspack_import_17/* .indexedByDefault */.w5)(spec) && !unique) {
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
                     column: spec.code
                 }), async ()=>{
-                    await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, spec.code, ctx.driver, this.adapter));
+                    await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, spec.code, ctx.driver, this.adapter, this.liveOnly(definition, ctx.driver)));
                 });
             }
             let savedFieldId = null;
@@ -3974,7 +4368,7 @@ class SchemaEvolutionService {
                     dbType,
                     nullable,
                     unique,
-                    isIndexed: spec.isIndexed ?? false,
+                    isIndexed: (0,_schema_columns_js__rspack_import_17/* .indexedByDefault */.w5)(spec),
                     defaultValue: spec.defaultValue ?? null,
                     validationRules: spec.validationRules ?? null,
                     selectOptions: spec.selectOptions ?? null,
@@ -3988,7 +4382,7 @@ class SchemaEvolutionService {
                 savedFieldId = saved.id;
             });
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ADD_COLUMN */.i.ADD_COLUMN,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.ADD_COLUMN */.i.ADD_COLUMN,
                 fieldDefinitionId: savedFieldId,
                 diff: {
                     field: {
@@ -4016,11 +4410,11 @@ class SchemaEvolutionService {
         if (loadedField.deprecatedAt) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: 'A deprecated field cannot be changed. Restore it first.',
-                messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.DEPRECATED_LOCKED */.oc.DEPRECATED_LOCKED
+                messageKey: _config_message_keys_js__rspack_import_20/* .FIELD_DEFINITION_MESSAGES.DEPRECATED_LOCKED */.oc.DEPRECATED_LOCKED
             });
         }
         const newCode = typeof changes.code === 'string' && changes.code !== loadedField.code ? changes.code : null;
-        if (newCode) (0,_identifier_rules_js__rspack_import_14/* .assertValidIdentifier */.kV)(newCode, 'field');
+        if (newCode) (0,_identifier_rules_js__rspack_import_14/* .assertValidIdentifier */.k)(newCode, 'field');
         const structuralKeys = (field)=>[
                 'fieldType',
                 'nullable',
@@ -4031,7 +4425,7 @@ class SchemaEvolutionService {
         if (newCode && requested.length) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: `Rename '${loadedField.code}' in its own change - it cannot be combined with: ${requested.join(', ')}.`,
-                messageKey: _config_message_keys_js__rspack_import_19/* .FIELD_DEFINITION_MESSAGES.RENAME_ALONE */.oc.RENAME_ALONE,
+                messageKey: _config_message_keys_js__rspack_import_20/* .FIELD_DEFINITION_MESSAGES.RENAME_ALONE */.oc.RENAME_ALONE,
                 messageVariables: {
                     field: loadedField.code,
                     changes: requested.join(', ')
@@ -4043,7 +4437,7 @@ class SchemaEvolutionService {
             'unique',
             'isIndexed'
         ].some((k)=>k in changes)) {
-            (0,_identifier_rules_js__rspack_import_14/* .assertIndexableField */.fY)({
+            (0,_identifier_rules_js__rspack_import_14/* .assertIndexableField */.f)({
                 ...loadedField,
                 ...changes,
                 code: loadedField.code
@@ -4051,10 +4445,10 @@ class SchemaEvolutionService {
         }
         const targetType = changes.fieldType ?? loadedField.fieldType;
         const newTargetId = typeof changes.relationTargetEntityId === 'string' ? changes.relationTargetEntityId : null;
-        if (newTargetId && targetType !== _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION) {
+        if (newTargetId && targetType !== _enums_field_type_enum_js__rspack_import_21/* .FieldType.RELATION */.P.RELATION) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: 'relationTargetEntityId can only be set on a RELATION field.',
-                messageKey: _config_message_keys_js__rspack_import_19/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
+                messageKey: _config_message_keys_js__rspack_import_20/* .SCHEMA_MESSAGES.INVALID_CHANGE_VALUE */.Hu.INVALID_CHANGE_VALUE,
                 messageVariables: {
                     property: 'relationTargetEntityId'
                 }
@@ -4068,7 +4462,7 @@ class SchemaEvolutionService {
             const { definition, fields, field } = await this.current(ctx, request, loaded.id, loadedField.id);
             if (this.changedUnderneath(ctx, loadedField, field)) {
                 return {
-                    operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
+                    operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
                     fieldDefinitionId: field.id,
                     diff: {}
                 };
@@ -4082,7 +4476,7 @@ class SchemaEvolutionService {
             const table = structural.length || newCode ? await this.requireTable(ctx, definition.tableName) : undefined;
             const column = table?.findColumnByName(field.code);
             if ((structural.length || newCode) && table && !column) {
-                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.COLUMN_MISSING */.M3.COLUMN_MISSING, {
+                ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.COLUMN_MISSING */.M3.COLUMN_MISSING, {
                     column: field.code
                 }));
             }
@@ -4097,10 +4491,10 @@ class SchemaEvolutionService {
             }
             if ('selectOptions' in changes) {
                 patch.selectOptions = changes.selectOptions;
-                if (merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT && Array.isArray(changes.selectOptions) && changes.selectOptions.length && !ctx.blocked) {
+                if (merged.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT && Array.isArray(changes.selectOptions) && changes.selectOptions.length && !ctx.blocked) {
                     const values = changes.selectOptions.map((o)=>String(o.value));
                     const stray = await this.advisoryScalar(ctx, (0,_flusys_nestjs_shared_classes__rspack_import_0.buildQuery)(`SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL AND ${ctx.q(field.code)} NOT IN (${values.map(()=>'?').join(', ')})`, ctx.driver), values);
-                    if (stray > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.STRAY_VALUES */.Uu.STRAY_VALUES, {
+                    if (stray > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.STRAY_VALUES */.Uu.STRAY_VALUES, {
                         count: stray
                     }));
                 }
@@ -4108,31 +4502,31 @@ class SchemaEvolutionService {
             if ('validationRules' in changes) {
                 patch.validationRules = changes.validationRules;
                 const rules = changes.validationRules ?? {};
-                const isNumber = merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.INTEGER */.P.INTEGER || merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.DECIMAL */.P.DECIMAL;
+                const isNumber = merged.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.INTEGER */.P.INTEGER || merged.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.DECIMAL */.P.DECIMAL;
                 const violating = [];
                 if (isNumber && typeof rules.min === 'number') violating.push(`${ctx.q(field.code)} < ${Number(rules.min)}`);
                 if (isNumber && typeof rules.max === 'number') violating.push(`${ctx.q(field.code)} > ${Number(rules.max)}`);
                 if (!isNumber && typeof rules.minLength === 'number') violating.push(`CHAR_LENGTH(${ctx.q(field.code)}) < ${Number(rules.minLength)}`);
                 if (!isNumber && typeof rules.maxLength === 'number') violating.push(`CHAR_LENGTH(${ctx.q(field.code)}) > ${Number(rules.maxLength)}`);
                 if (violating.length && [
-                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.INTEGER */.P.INTEGER,
-                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.DECIMAL */.P.DECIMAL,
-                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.TEXT */.P.TEXT,
-                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
-                    _enums_field_type_enum_js__rspack_import_20/* .FieldType.EMAIL */.P.EMAIL
+                    _enums_field_type_enum_js__rspack_import_21/* .FieldType.INTEGER */.P.INTEGER,
+                    _enums_field_type_enum_js__rspack_import_21/* .FieldType.DECIMAL */.P.DECIMAL,
+                    _enums_field_type_enum_js__rspack_import_21/* .FieldType.TEXT */.P.TEXT,
+                    _enums_field_type_enum_js__rspack_import_21/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
+                    _enums_field_type_enum_js__rspack_import_21/* .FieldType.EMAIL */.P.EMAIL
                 ].includes(merged.fieldType)) {
                     const bad = await this.advisoryScalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL AND (${violating.join(' OR ')})`);
-                    if (bad > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.RULES_VIOLATED */.Uu.RULES_VIOLATED, {
+                    if (bad > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.RULES_VIOLATED */.Uu.RULES_VIOLATED, {
                         count: bad
                     }));
                 }
             }
             // ── relation target ──
-            if (merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION) {
+            if (merged.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.RELATION */.P.RELATION) {
                 const targetId = 'relationTargetEntityId' in changes ? changes.relationTargetEntityId : field.relationTargetEntityId;
-                const becomesRelation = field.fieldType !== _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION;
+                const becomesRelation = field.fieldType !== _enums_field_type_enum_js__rspack_import_21/* .FieldType.RELATION */.P.RELATION;
                 if (!targetId && (becomesRelation || 'relationTargetEntityId' in changes)) {
-                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
+                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
                         field: field.code
                     }));
                 } else if (targetId && (becomesRelation || targetId !== field.relationTargetEntityId)) {
@@ -4141,7 +4535,7 @@ class SchemaEvolutionService {
                             id: targetId
                         }
                     });
-                    if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_MISSING */.M3.RELATION_TARGET_MISSING));
+                    if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_MISSING */.M3.RELATION_TARGET_MISSING));
                     else if (target.id !== field.relationTargetEntityId) patch.relationTargetEntityId = target.id;
                 }
             } else if (field.relationTargetEntityId && changes.fieldType !== undefined) {
@@ -4150,7 +4544,7 @@ class SchemaEvolutionService {
             if ('defaultValue' in changes) {
                 if (changes.defaultValue !== null && changes.defaultValue !== undefined) {
                     const problem = this.checkValue(merged, changes.defaultValue);
-                    if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
+                    if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
                         problem
                     }));
                 }
@@ -4169,7 +4563,7 @@ class SchemaEvolutionService {
                         const where = check.badRowsWhere(ctx.q(field.code), ctx.driver);
                         const bad = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL AND (${where})`);
                         if (bad > 0) {
-                            ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.CONVERSION_BAD_ROWS */.M3.CONVERSION_BAD_ROWS, {
+                            ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.CONVERSION_BAD_ROWS */.M3.CONVERSION_BAD_ROWS, {
                                 count: bad,
                                 check: check.description,
                                 from: field.fieldType,
@@ -4182,12 +4576,12 @@ class SchemaEvolutionService {
                         ctx.markDestructive();
                     }
                     const newDefaultProblem = merged.defaultValue !== null && merged.defaultValue !== undefined ? this.checkValue(merged, merged.defaultValue) : null;
-                    if (newDefaultProblem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.CURRENT_DEFAULT_INVALID */.M3.CURRENT_DEFAULT_INVALID, {
+                    if (newDefaultProblem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.CURRENT_DEFAULT_INVALID */.M3.CURRENT_DEFAULT_INVALID, {
                         type: merged.fieldType,
                         problem: newDefaultProblem
                     }));
-                    if ((merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT || merged.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) && !merged.selectOptions?.length) {
-                        ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.NO_SELECT_OPTIONS_CONVERT */.Uu.NO_SELECT_OPTIONS_CONVERT));
+                    if ((merged.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT || merged.fieldType === _enums_field_type_enum_js__rspack_import_21/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) && !merged.selectOptions?.length) {
+                        ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.NO_SELECT_OPTIONS_CONVERT */.Uu.NO_SELECT_OPTIONS_CONVERT));
                     }
                     if (!ctx.blocked) {
                         const newDbType = this.adapter.mapFieldType(merged.fieldType, ctx.driver);
@@ -4199,7 +4593,7 @@ class SchemaEvolutionService {
                             const nullSql = column.isNullable ? 'NULL' : 'NOT NULL';
                             const up = ctx.driver === 'postgres' ? `ALTER TABLE ${t} ALTER COLUMN ${c} TYPE ${to} USING ${conversion.using ? conversion.using(c) : `${c}::${to}`}` : `ALTER TABLE ${t} MODIFY ${c} ${to} ${nullSql}`;
                             const down = ctx.driver === 'postgres' ? `ALTER TABLE ${t} ALTER COLUMN ${c} TYPE ${from} USING ${c}::${from}` : `ALTER TABLE ${t} MODIFY ${c} ${from} ${nullSql}`;
-                            await ctx.rawDdl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.CONVERT_TYPE */.EQ.CONVERT_TYPE, {
+                            await ctx.rawDdl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.CONVERT_TYPE */.EQ.CONVERT_TYPE, {
                                 column: field.code,
                                 from: field.fieldType,
                                 to: merged.fieldType
@@ -4220,21 +4614,21 @@ class SchemaEvolutionService {
                     const nulls = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NULL`);
                     const value = request.backfillValue ?? merged.defaultValue ?? null;
                     if (nulls > 0 && value === null) {
-                        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.NULLS_NEED_VALUE */.M3.NULLS_NEED_VALUE, {
+                        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.NULLS_NEED_VALUE */.M3.NULLS_NEED_VALUE, {
                             count: nulls,
                             field: field.code
                         }));
                     } else if (nulls > 0) {
                         const problem = this.checkValue(merged, value);
-                        if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.BACKFILL_INVALID */.M3.BACKFILL_INVALID, {
+                        if (problem) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.BACKFILL_INVALID */.M3.BACKFILL_INVALID, {
                             problem
                         }));
                         else {
-                            ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.BACKFILL_WILL_SET */.Uu.BACKFILL_WILL_SET, {
+                            ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.BACKFILL_WILL_SET */.Uu.BACKFILL_WILL_SET, {
                                 count: nulls,
                                 value: JSON.stringify(value)
                             }));
-                            await ctx.data((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.BACKFILL_RECORDS */.EQ.BACKFILL_RECORDS, {
+                            await ctx.data((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.BACKFILL_RECORDS */.EQ.BACKFILL_RECORDS, {
                                 count: nulls
                             }), `UPDATE ${ctx.q(definition.tableName)} SET ${ctx.q(field.code)} = ${this.adapter.sqlLiteral(this.paramValue(merged.fieldType, value), ctx.driver)} WHERE ${ctx.q(field.code)} IS NULL`, async ()=>{
                                 await ctx.qr.query((0,_flusys_nestjs_shared_classes__rspack_import_0.buildQuery)(`UPDATE ${ctx.q(definition.tableName)} SET ${ctx.q(field.code)} = ? WHERE ${ctx.q(field.code)} IS NULL`, ctx.driver), [
@@ -4256,19 +4650,19 @@ class SchemaEvolutionService {
                 if (changes.unique === true) {
                     const dups = await this.countDuplicates(ctx, definition.tableName, field.code);
                     if (dups > 0) {
-                        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DUPLICATE_VALUES */.M3.DUPLICATE_VALUES, {
+                        ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.DUPLICATE_VALUES */.M3.DUPLICATE_VALUES, {
                             count: dups,
                             field: field.code
                         }));
                     } else {
-                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_UNIQUE */.EQ.ADD_UNIQUE, {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_UNIQUE */.EQ.ADD_UNIQUE, {
                             column: field.code
                         }), async ()=>{
                             await (0,_schema_columns_js__rspack_import_17/* .addUnique */.$6)(ctx.qr, table, field.code, ctx.driver, this.adapter);
                         });
                     }
                 } else {
-                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.REMOVE_UNIQUE */.EQ.REMOVE_UNIQUE, {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.REMOVE_UNIQUE */.EQ.REMOVE_UNIQUE, {
                         column: field.code
                     }), async ()=>this.dropUniques(ctx, table, field.code));
                 }
@@ -4277,13 +4671,13 @@ class SchemaEvolutionService {
             // ── index ──
             if (changes.isIndexed !== undefined && changes.isIndexed !== field.isIndexed && table && column && !ctx.blocked) {
                 if (changes.isIndexed) {
-                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
                         column: field.code
                     }), async ()=>{
-                        await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, field.code, ctx.driver, this.adapter));
+                        await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, field.code, ctx.driver, this.adapter, this.liveOnly(definition, ctx.driver)));
                     });
                 } else {
-                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.REMOVE_INDEX */.EQ.REMOVE_INDEX, {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.REMOVE_INDEX */.EQ.REMOVE_INDEX, {
                         column: field.code
                     }), async ()=>{
                         for (const idx of this.indexOn(table, field.code, false))await ctx.qr.dropIndex(table, idx);
@@ -4294,22 +4688,22 @@ class SchemaEvolutionService {
             // ── rename ──
             if (newCode && table && column) {
                 const taken = fields.find((f)=>f.code === newCode);
-                if (taken) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(taken.deprecatedAt ? _config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.FIELD_CODE_TAKEN_DEPRECATED */.M3.FIELD_CODE_TAKEN_DEPRECATED : _config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.FIELD_CODE_TAKEN */.M3.FIELD_CODE_TAKEN, {
+                if (taken) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(taken.deprecatedAt ? _config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.FIELD_CODE_TAKEN_DEPRECATED */.M3.FIELD_CODE_TAKEN_DEPRECATED : _config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.FIELD_CODE_TAKEN */.M3.FIELD_CODE_TAKEN, {
                     code: newCode
                 }));
                 if (impact.length && request.rewriteReferences === false) {
-                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.RENAME_IN_USE */.M3.RENAME_IN_USE, {
+                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.RENAME_IN_USE */.M3.RENAME_IN_USE, {
                         field: field.code,
-                        references: (0,_schema_change_types_js__rspack_import_22/* .describeImpact */.a)(impact)
+                        references: (0,_schema_change_types_js__rspack_import_23/* .describeImpact */.a)(impact)
                     }));
                 } else if (impact.length) {
-                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.REFERENCES_REWRITTEN */.Uu.REFERENCES_REWRITTEN, {
+                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.REFERENCES_REWRITTEN */.Uu.REFERENCES_REWRITTEN, {
                         count: impact.length,
                         code: newCode
                     }));
                 }
                 if (!ctx.blocked) {
-                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RENAME_COLUMN */.EQ.RENAME_COLUMN, {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RENAME_COLUMN */.EQ.RENAME_COLUMN, {
                         from: field.code,
                         to: newCode
                     }), async ()=>{
@@ -4318,15 +4712,14 @@ class SchemaEvolutionService {
                     // TypeORM moves the index/unique onto the renamed column but keeps its name, which is
                     // derived from the old code - recreate them so a new field with the old code can have its own.
                     if (field.isIndexed && !field.unique) {
-                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RENAME_INDEX */.EQ.RENAME_INDEX, {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RENAME_INDEX */.EQ.RENAME_INDEX, {
                             column: field.code
                         }), async ()=>{
-                            for (const idx of this.indexOn(table, newCode, false))await ctx.qr.dropIndex(table, idx);
-                            await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, newCode, ctx.driver, this.adapter));
+                            await this.rebuildPlainIndex(ctx, table, definition.tableName, newCode, this.liveOnly(definition, ctx.driver));
                         });
                     }
                     if (field.unique) {
-                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RENAME_INDEX */.EQ.RENAME_INDEX, {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RENAME_INDEX */.EQ.RENAME_INDEX, {
                             column: field.code
                         }), async ()=>{
                             await this.dropUniques(ctx, table, newCode);
@@ -4337,7 +4730,7 @@ class SchemaEvolutionService {
                 }
             }
             if (ctx.blocked) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
                 fieldDefinitionId: field.id,
                 diff: {}
             };
@@ -4349,7 +4742,7 @@ class SchemaEvolutionService {
             });
             const metadataOnly = !structural.length && !newCode;
             return {
-                operation: newCode ? _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.RENAME_FIELD */.i.RENAME_FIELD : _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
+                operation: newCode ? _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.RENAME_FIELD */.i.RENAME_FIELD : _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.ALTER_FIELD */.i.ALTER_FIELD,
                 fieldDefinitionId: field.id,
                 diff: {
                     field: field.code,
@@ -4360,13 +4753,7 @@ class SchemaEvolutionService {
                         ])),
                     after: patch
                 },
-                bumpVersion: !metadataOnly || Object.keys(patch).some((k)=>[
-                        'selectOptions',
-                        'validationRules',
-                        'defaultValue',
-                        'label',
-                        'relationTargetEntityId'
-                    ].includes(k))
+                bumpVersion: !metadataOnly || Object.keys(patch).some((k)=>FIELD_CACHE_KEYS.has(k))
             };
         };
         return {
@@ -4381,23 +4768,23 @@ class SchemaEvolutionService {
         const impact = await this.references.forField(loaded.code, loadedField.code);
         const run = async (ctx)=>{
             const { definition, field } = await this.current(ctx, request, loaded.id, loadedField.id);
-            if (field.code !== loadedField.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DEFINITION_CHANGED */.M3.DEFINITION_CHANGED));
-            if (field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.ALREADY_DEPRECATED */.M3.ALREADY_DEPRECATED, {
+            if (field.code !== loadedField.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.DEFINITION_CHANGED */.M3.DEFINITION_CHANGED));
+            if (field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.ALREADY_DEPRECATED */.M3.ALREADY_DEPRECATED, {
                 field: field.code
             }));
-            if (impact.length) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.STILL_REFERENCED */.Uu.STILL_REFERENCED, {
-                references: (0,_schema_change_types_js__rspack_import_22/* .describeImpact */.a)(impact)
+            if (impact.length) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.STILL_REFERENCED */.Uu.STILL_REFERENCED, {
+                references: (0,_schema_change_types_js__rspack_import_23/* .describeImpact */.a)(impact)
             }));
             const table = await this.requireTable(ctx, definition.tableName);
             const column = table?.findColumnByName(field.code);
             if (ctx.blocked) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.MARK_DEPRECATED */.i.MARK_DEPRECATED,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.MARK_DEPRECATED */.i.MARK_DEPRECATED,
                 fieldDefinitionId: field.id,
                 diff: {}
             };
             // A hidden NOT NULL column would make every new record fail (nobody supplies it any more).
             if (column && !column.isNullable) {
-                await this.setRequired(ctx, definition.tableName, field.code, field.fieldType, false, _config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RELAX_DEPRECATED */.EQ.RELAX_DEPRECATED);
+                await this.setRequired(ctx, definition.tableName, field.code, field.fieldType, false, _config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RELAX_DEPRECATED */.EQ.RELAX_DEPRECATED);
             }
             await ctx.metadata(async ()=>{
                 await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).update(field.id, {
@@ -4406,7 +4793,7 @@ class SchemaEvolutionService {
                 });
             });
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.MARK_DEPRECATED */.i.MARK_DEPRECATED,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.MARK_DEPRECATED */.i.MARK_DEPRECATED,
                 fieldDefinitionId: field.id,
                 diff: {
                     field: field.code
@@ -4423,15 +4810,15 @@ class SchemaEvolutionService {
         const { field: loadedField, definition: loaded } = await this.loadField(request.fieldDefinitionId);
         const run = async (ctx)=>{
             const { definition, field } = await this.current(ctx, request, loaded.id, loadedField.id);
-            if (!field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.NOT_DEPRECATED */.M3.NOT_DEPRECATED, {
+            if (!field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.NOT_DEPRECATED */.M3.NOT_DEPRECATED, {
                 field: field.code
             }));
             const table = await this.requireTable(ctx, definition.tableName);
-            if (table && !table.findColumnByName(field.code)) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.COLUMN_GONE */.M3.COLUMN_GONE, {
+            if (table && !table.findColumnByName(field.code)) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.COLUMN_GONE */.M3.COLUMN_GONE, {
                 column: field.code
             }));
             if (ctx.blocked) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.RESTORE_FIELD */.i.RESTORE_FIELD,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.RESTORE_FIELD */.i.RESTORE_FIELD,
                 fieldDefinitionId: field.id,
                 diff: {}
             };
@@ -4440,9 +4827,9 @@ class SchemaEvolutionService {
                     deprecatedAt: null
                 });
             });
-            ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.FIELD_OPTIONAL_AGAIN */.Uu.FIELD_OPTIONAL_AGAIN));
+            ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.FIELD_OPTIONAL_AGAIN */.Uu.FIELD_OPTIONAL_AGAIN));
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.RESTORE_FIELD */.i.RESTORE_FIELD,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.RESTORE_FIELD */.i.RESTORE_FIELD,
                 fieldDefinitionId: field.id,
                 diff: {
                     field: field.code
@@ -4461,45 +4848,45 @@ class SchemaEvolutionService {
         const run = async (ctx)=>{
             const { definition, field } = await this.current(ctx, request, loaded.id, loadedField.id);
             if (this.changedUnderneath(ctx, loadedField, field)) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
                 fieldDefinitionId: field.id,
                 diff: {}
             };
-            if (!field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.PURGE_REQUIRES_DEPRECATED */.M3.PURGE_REQUIRES_DEPRECATED));
-            if (request.confirmCode !== field.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.PURGE_CONFIRM_CODE */.M3.PURGE_CONFIRM_CODE, {
+            if (!field.deprecatedAt) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.PURGE_REQUIRES_DEPRECATED */.M3.PURGE_REQUIRES_DEPRECATED));
+            if (request.confirmCode !== field.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.PURGE_CONFIRM_CODE */.M3.PURGE_CONFIRM_CODE, {
                 code: field.code
             }));
-            if (impact.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.PURGE_IN_USE */.M3.PURGE_IN_USE, {
+            if (impact.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.PURGE_IN_USE */.M3.PURGE_IN_USE, {
                 field: field.code,
-                references: (0,_schema_change_types_js__rspack_import_22/* .describeImpact */.a)(impact)
+                references: (0,_schema_change_types_js__rspack_import_23/* .describeImpact */.a)(impact)
             }));
             const table = await this.requireTable(ctx, definition.tableName);
             const column = table?.findColumnByName(field.code);
             if (ctx.blocked) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
                 fieldDefinitionId: field.id,
                 diff: {}
             };
             if (table && column) {
                 const values = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NOT NULL`);
                 ctx.setAffectedRows(values);
-                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.VALUES_DELETED */.Uu.VALUES_DELETED, {
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.VALUES_DELETED */.Uu.VALUES_DELETED, {
                     count: values
                 }));
-                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.DROP_COLUMN */.EQ.DROP_COLUMN, {
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.DROP_COLUMN */.EQ.DROP_COLUMN, {
                     column: field.code
                 }), async ()=>{
                     await ctx.qr.dropColumn(table, column);
                 });
             } else {
-                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.COLUMN_ALREADY_MISSING */.Uu.COLUMN_ALREADY_MISSING));
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.COLUMN_ALREADY_MISSING */.Uu.COLUMN_ALREADY_MISSING));
             }
             ctx.markDestructive();
             await ctx.metadata(async ()=>{
                 await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).delete(field.id);
             });
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.DROP_COLUMN */.i.DROP_COLUMN,
                 fieldDefinitionId: null,
                 diff: {
                     field: field.code,
@@ -4519,16 +4906,16 @@ class SchemaEvolutionService {
         const changes = request.changes ?? {};
         this.rejectUnknownKeys(changes, _dtos_schema_change_dto_js__rspack_import_6/* .ENTITY_CHANGE_KEYS */.Oi, 'entity');
         if (changes.status !== undefined && ![
-            _enums_entity_status_enum_js__rspack_import_23/* .EntityStatus.ACTIVE */.c.ACTIVE,
-            _enums_entity_status_enum_js__rspack_import_23/* .EntityStatus.DEPRECATED */.c.DEPRECATED
+            _enums_entity_status_enum_js__rspack_import_24/* .EntityStatus.ACTIVE */.c.ACTIVE,
+            _enums_entity_status_enum_js__rspack_import_24/* .EntityStatus.DEPRECATED */.c.DEPRECATED
         ].includes(changes.status)) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: "status must be 'ACTIVE' or 'DEPRECATED'.",
-                messageKey: _config_message_keys_js__rspack_import_19/* .ENTITY_DEFINITION_MESSAGES.INVALID_STATUS */.pL.INVALID_STATUS
+                messageKey: _config_message_keys_js__rspack_import_20/* .ENTITY_DEFINITION_MESSAGES.INVALID_STATUS */.pL.INVALID_STATUS
             });
         }
         this.validateChanges(_dtos_schema_change_dto_js__rspack_import_6/* .EntityChangesDto */.OW, changes);
-        const impact = changes.status === _enums_entity_status_enum_js__rspack_import_23/* .EntityStatus.DEPRECATED */.c.DEPRECATED ? await this.references.forEntity(loaded.code) : [];
+        const impact = changes.status === _enums_entity_status_enum_js__rspack_import_24/* .EntityStatus.DEPRECATED */.c.DEPRECATED ? await this.references.forEntity(loaded.code) : [];
         const run = async (ctx)=>{
             const { definition } = await this.current(ctx, request, loaded.id);
             const patch = {};
@@ -4545,37 +4932,38 @@ class SchemaEvolutionService {
             const touchesColumns = wantsSoft === true && !definition.isSoftDeleteEnabled || wantsAudit === true && !definition.isAuditEnabled;
             const table = touchesColumns ? await this.requireTable(ctx, definition.tableName) : undefined;
             if (ctx.blocked) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_ENTITY */.i.ALTER_ENTITY,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.ALTER_ENTITY */.i.ALTER_ENTITY,
                 diff: {}
             };
             if (wantsSoft !== undefined && wantsSoft !== definition.isSoftDeleteEnabled) {
                 if (wantsSoft && table) {
                     if (!table.findColumnByName('deleted_at')) {
-                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_DELETED_AT */.EQ.ADD_DELETED_AT), async ()=>{
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_DELETED_AT */.EQ.ADD_DELETED_AT), async ()=>{
                             await ctx.qr.addColumn(table, (0,_schema_columns_js__rspack_import_17/* .softDeleteColumn */.OG)());
                         });
                     }
                 } else if (!wantsSoft) {
-                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.SOFT_DELETE_OFF */.Uu.SOFT_DELETE_OFF));
+                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.SOFT_DELETE_OFF */.Uu.SOFT_DELETE_OFF));
                     ctx.markDestructive();
                 }
                 patch.isSoftDeleteEnabled = wantsSoft;
+                await this.reshapePlainIndexes(ctx, definition, wantsSoft);
             }
             if (wantsAudit !== undefined && wantsAudit !== definition.isAuditEnabled) {
                 if (wantsAudit && table) {
                     const missing = (0,_schema_columns_js__rspack_import_17/* .auditColumns */.HK)(ctx.driver).filter((c)=>!table.findColumnByName(c.name));
                     if (missing.length) {
-                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_AUDIT_COLUMNS */.EQ.ADD_AUDIT_COLUMNS), async ()=>{
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_AUDIT_COLUMNS */.EQ.ADD_AUDIT_COLUMNS), async ()=>{
                             for (const c of missing)await ctx.qr.addColumn(table, c);
                         });
                     }
                 } else if (!wantsAudit) {
-                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.AUDIT_OFF */.Uu.AUDIT_OFF));
+                    ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.AUDIT_OFF */.Uu.AUDIT_OFF));
                 }
                 patch.isAuditEnabled = wantsAudit;
             }
-            if (changes.status === _enums_entity_status_enum_js__rspack_import_23/* .EntityStatus.DEPRECATED */.c.DEPRECATED && impact.length) {
-                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.ENTITY_REFERENCED */.Uu.ENTITY_REFERENCED, {
+            if (changes.status === _enums_entity_status_enum_js__rspack_import_24/* .EntityStatus.DEPRECATED */.c.DEPRECATED && impact.length) {
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.ENTITY_REFERENCED */.Uu.ENTITY_REFERENCED, {
                     count: impact.length
                 }));
             }
@@ -4583,7 +4971,7 @@ class SchemaEvolutionService {
                 if (Object.keys(patch).length) await ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f).update(definition.id, patch);
             });
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ALTER_ENTITY */.i.ALTER_ENTITY,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.ALTER_ENTITY */.i.ALTER_ENTITY,
                 diff: {
                     changed: Object.keys(patch),
                     after: patch
@@ -4596,6 +4984,32 @@ class SchemaEvolutionService {
             impact
         };
     }
+    /**
+   * Soft delete switched on or off: a plain index over live rows only is of no use to reads that no longer
+   * ask for live rows (and the other way round), so every plain index takes the shape the entity now wants.
+   */ async reshapePlainIndexes(ctx, definition, softDelete) {
+        if (ctx.driver !== 'postgres') return;
+        const table = await ctx.qr.getTable(definition.tableName);
+        if (!table) return;
+        const liveOnly = this.liveOnly({
+            isSoftDeleteEnabled: softDelete
+        }, ctx.driver);
+        const fields = await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).find({
+            where: {
+                entityDefinitionId: definition.id
+            }
+        });
+        for (const field of fields.filter((f)=>f.isIndexed && !f.unique && table.findColumnByName(f.code))){
+            // A missing index is left to `repair`; only one of the wrong shape is rebuilt here.
+            const existing = this.indexOn(table, field.code, false);
+            if (!existing.length || existing.every((index)=>(0,_schema_columns_js__rspack_import_17/* .isLiveRowsIndex */.YS)(index) === liveOnly)) continue;
+            await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RECREATE_INDEX */.EQ.RECREATE_INDEX, {
+                column: field.code
+            }), async ()=>{
+                await this.rebuildPlainIndex(ctx, table, definition.tableName, field.code, liveOnly);
+            });
+        }
+    }
     /** `"orders.customer_id", ...` - relation fields of other entities that point at this one. */ async relationsInto(ctx, definition) {
         const pointing = (await ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c).find({
             where: {
@@ -4621,34 +5035,34 @@ class SchemaEvolutionService {
         const impact = await this.references.forEntity(loaded.code);
         const run = async (ctx)=>{
             const { definition } = await this.current(ctx, request, loaded.id);
-            if (request.confirmCode !== definition.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DROP_CONFIRM_CODE */.M3.DROP_CONFIRM_CODE, {
+            if (request.confirmCode !== definition.code) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.DROP_CONFIRM_CODE */.M3.DROP_CONFIRM_CODE, {
                 code: definition.code
             }));
-            if (impact.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DROP_IN_USE */.M3.DROP_IN_USE, {
-                references: (0,_schema_change_types_js__rspack_import_22/* .describeImpact */.a)(impact)
+            if (impact.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.DROP_IN_USE */.M3.DROP_IN_USE, {
+                references: (0,_schema_change_types_js__rspack_import_23/* .describeImpact */.a)(impact)
             }));
             const relations = await this.relationsInto(ctx, definition);
-            if (relations) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_BLOCKER_MESSAGES.DROP_RELATION_IN_USE */.M3.DROP_RELATION_IN_USE, {
+            if (relations) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_BLOCKER_MESSAGES.DROP_RELATION_IN_USE */.M3.DROP_RELATION_IN_USE, {
                 fields: relations
             }));
             const table = await ctx.qr.getTable(definition.tableName);
             if (ctx.blocked) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_TABLE */.i.DROP_TABLE,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.DROP_TABLE */.i.DROP_TABLE,
                 diff: {}
             };
             if (table) {
                 const rows = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)}`);
                 ctx.setAffectedRows(rows);
-                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.RECORDS_DELETED */.Uu.RECORDS_DELETED, {
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.RECORDS_DELETED */.Uu.RECORDS_DELETED, {
                     count: rows
                 }));
-                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.DROP_TABLE */.EQ.DROP_TABLE, {
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.DROP_TABLE */.EQ.DROP_TABLE, {
                     table: definition.tableName
                 }), async ()=>{
                     await ctx.qr.dropTable(table);
                 });
             } else {
-                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.TABLE_ALREADY_MISSING */.Uu.TABLE_ALREADY_MISSING));
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.TABLE_ALREADY_MISSING */.Uu.TABLE_ALREADY_MISSING));
             }
             ctx.markDestructive();
             await ctx.metadata(async ()=>{
@@ -4658,7 +5072,7 @@ class SchemaEvolutionService {
                 await ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f).delete(definition.id);
             });
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.DROP_TABLE */.i.DROP_TABLE,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.DROP_TABLE */.i.DROP_TABLE,
                 diff: {
                     entity: definition.code
                 },
@@ -4679,7 +5093,7 @@ class SchemaEvolutionService {
             findings.push({
                 kind: 'missing_table',
                 severity: 'error',
-                ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.MISSING_TABLE */.Vu.MISSING_TABLE, {
+                ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.MISSING_TABLE */.Vu.MISSING_TABLE, {
                     table: definition.tableName
                 }),
                 repairable: true
@@ -4699,7 +5113,7 @@ class SchemaEvolutionService {
                     kind: 'missing_column',
                     severity: 'error',
                     field: name,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.SYSTEM_COLUMN_MISSING */.Vu.SYSTEM_COLUMN_MISSING, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.SYSTEM_COLUMN_MISSING */.Vu.SYSTEM_COLUMN_MISSING, {
                         column: name
                     }),
                     repairable: name !== 'id'
@@ -4714,7 +5128,7 @@ class SchemaEvolutionService {
                     kind: 'missing_column',
                     severity: field.deprecatedAt ? 'warning' : 'error',
                     field: field.code,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.COLUMN_MISSING */.Vu.COLUMN_MISSING, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.COLUMN_MISSING */.Vu.COLUMN_MISSING, {
                         column: field.code
                     }),
                     repairable: true
@@ -4729,7 +5143,7 @@ class SchemaEvolutionService {
                     kind: 'type_mismatch',
                     severity: 'error',
                     field: field.code,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.TYPE_MISMATCH */.Vu.TYPE_MISMATCH, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.TYPE_MISMATCH */.Vu.TYPE_MISMATCH, {
                         column: field.code,
                         actual: column.type,
                         fieldType: field.fieldType,
@@ -4743,7 +5157,7 @@ class SchemaEvolutionService {
                     kind: 'nullability_mismatch',
                     severity: 'warning',
                     field: field.code,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.REQUIRED_BUT_NULLABLE */.Vu.REQUIRED_BUT_NULLABLE, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.REQUIRED_BUT_NULLABLE */.Vu.REQUIRED_BUT_NULLABLE, {
                         column: field.code
                     }),
                     repairable: true
@@ -4754,18 +5168,19 @@ class SchemaEvolutionService {
                     kind: 'nullability_mismatch',
                     severity: 'warning',
                     field: field.code,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.OPTIONAL_BUT_NOT_NULL */.Vu.OPTIONAL_BUT_NOT_NULL, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.OPTIONAL_BUT_NOT_NULL */.Vu.OPTIONAL_BUT_NOT_NULL, {
                         column: field.code
                     }),
                     repairable: true
                 });
             }
-            if (field.isIndexed && !field.unique && this.indexOn(table, field.code, false).length === 0) {
+            // A plain index of the other shape (live rows only / all rows) counts as missing: repair rebuilds it.
+            if (field.isIndexed && !field.unique && !this.hasPlainIndex(table, field.code, this.liveOnly(definition, driver))) {
                 findings.push({
                     kind: 'missing_index',
                     severity: 'warning',
                     field: field.code,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.INDEX_MISSING */.Vu.INDEX_MISSING, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.INDEX_MISSING */.Vu.INDEX_MISSING, {
                         column: field.code
                     }),
                     repairable: true
@@ -4776,7 +5191,7 @@ class SchemaEvolutionService {
                     kind: 'missing_unique',
                     severity: 'warning',
                     field: field.code,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.UNIQUE_MISSING */.Vu.UNIQUE_MISSING, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.UNIQUE_MISSING */.Vu.UNIQUE_MISSING, {
                         column: field.code
                     }),
                     repairable: true
@@ -4787,7 +5202,7 @@ class SchemaEvolutionService {
                     kind: 'stale_metadata',
                     severity: 'warning',
                     field: field.code,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.STALE_METADATA */.Vu.STALE_METADATA, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.STALE_METADATA */.Vu.STALE_METADATA, {
                         dbType: field.dbType,
                         driver,
                         fieldType: field.fieldType
@@ -4802,7 +5217,7 @@ class SchemaEvolutionService {
                     kind: 'extra_column',
                     severity: 'warning',
                     field: column.name,
-                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_FINDING_MESSAGES.EXTRA_COLUMN */.Vu.EXTRA_COLUMN, {
+                    ...(0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_FINDING_MESSAGES.EXTRA_COLUMN */.Vu.EXTRA_COLUMN, {
                         column: column.name
                     }),
                     repairable: false
@@ -4833,24 +5248,24 @@ class SchemaEvolutionService {
                     columns,
                     uniques
                 });
-                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RECREATE_TABLE */.EQ.RECREATE_TABLE, {
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RECREATE_TABLE */.EQ.RECREATE_TABLE, {
                     table: definition.tableName
                 }), async ()=>{
                     await ctx.qr.createTable(recreated, false);
                 });
                 fixed.push('missing_table');
                 for (const indexed of fields.filter((f)=>f.isIndexed && !f.unique)){
-                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RECREATE_INDEX */.EQ.RECREATE_INDEX, {
+                    await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RECREATE_INDEX */.EQ.RECREATE_INDEX, {
                         column: indexed.code
                     }), async ()=>{
-                        await ctx.qr.createIndex(recreated, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, indexed.code, ctx.driver, this.adapter));
+                        await ctx.qr.createIndex(recreated, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, indexed.code, ctx.driver, this.adapter, this.liveOnly(definition, ctx.driver)));
                     });
                     fixed.push(`missing_index:${indexed.code}`);
                 }
-                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.TABLE_RECREATED_EMPTY */.Uu.TABLE_RECREATED_EMPTY));
+                ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.TABLE_RECREATED_EMPTY */.Uu.TABLE_RECREATED_EMPTY));
                 ctx.markDestructive();
                 return {
-                    operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.REPAIR */.i.REPAIR,
+                    operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.REPAIR */.i.REPAIR,
                     diff: {
                         fixed,
                         manual: 0
@@ -4864,16 +5279,16 @@ class SchemaEvolutionService {
                     case 'missing_column':
                         {
                             if (!field) {
-                                const sys = [
-                                    (0,_schema_columns_js__rspack_import_17/* .softDeleteColumn */.OG)(),
-                                    ...(0,_schema_columns_js__rspack_import_17/* .auditColumns */.HK)(ctx.driver)
-                                ].find((c)=>c.name === finding.field);
+                                const sys = (0,_schema_columns_js__rspack_import_17/* .buildSystemColumns */.Rm)({
+                                    isSoftDeleteEnabled: true,
+                                    isAuditEnabled: true
+                                }, ctx.driver).find((c)=>c.name === finding.field && !c.isPrimary);
                                 if (!sys) break;
-                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_SYSTEM_COLUMN */.EQ.ADD_SYSTEM_COLUMN, {
+                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_SYSTEM_COLUMN */.EQ.ADD_SYSTEM_COLUMN, {
                                     column: sys.name
                                 }), async ()=>ctx.qr.addColumn(table, sys));
                             } else {
-                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.ADD_MISSING_COLUMN */.EQ.ADD_MISSING_COLUMN, {
+                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.ADD_MISSING_COLUMN */.EQ.ADD_MISSING_COLUMN, {
                                     column: field.code
                                 }), async ()=>{
                                     await ctx.qr.addColumn(table, (0,_schema_columns_js__rspack_import_17/* .buildFieldColumn */.fu)(field, ctx.driver, this.adapter, {
@@ -4883,7 +5298,7 @@ class SchemaEvolutionService {
                                 });
                                 // Re-added columns start empty, so a required field stays nullable until its records have values.
                                 const rows = !field.nullable && !field.deprecatedAt ? await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)}`) : 0;
-                                if (rows > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.REQUIRED_HAS_NULLS */.Uu.REQUIRED_HAS_NULLS, {
+                                if (rows > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.REQUIRED_HAS_NULLS */.Uu.REQUIRED_HAS_NULLS, {
                                     field: field.code,
                                     count: rows
                                 }));
@@ -4892,10 +5307,10 @@ class SchemaEvolutionService {
                             break;
                         }
                     case 'missing_index':
-                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RECREATE_INDEX */.EQ.RECREATE_INDEX, {
+                        await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RECREATE_INDEX */.EQ.RECREATE_INDEX, {
                             column: finding.field
                         }), async ()=>{
-                            await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, finding.field, ctx.driver, this.adapter));
+                            await this.rebuildPlainIndex(ctx, table, definition.tableName, finding.field, this.liveOnly(definition, ctx.driver));
                         });
                         fixed.push(`missing_index:${finding.field}`);
                         break;
@@ -4903,12 +5318,12 @@ class SchemaEvolutionService {
                         {
                             const code = finding.field;
                             const dups = await this.countDuplicates(ctx, definition.tableName, code);
-                            if (dups > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.UNIQUE_NOT_RECREATED */.Uu.UNIQUE_NOT_RECREATED, {
+                            if (dups > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.UNIQUE_NOT_RECREATED */.Uu.UNIQUE_NOT_RECREATED, {
                                 field: code,
                                 count: dups
                             }));
                             else {
-                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_STEP_MESSAGES.RECREATE_UNIQUE */.EQ.RECREATE_UNIQUE, {
+                                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_STEP_MESSAGES.RECREATE_UNIQUE */.EQ.RECREATE_UNIQUE, {
                                     column: code
                                 }), async ()=>{
                                     await (0,_schema_columns_js__rspack_import_17/* .addUnique */.$6)(ctx.qr, table, code, ctx.driver, this.adapter);
@@ -4923,7 +5338,7 @@ class SchemaEvolutionService {
                             if (!field || !column) break;
                             if (!field.nullable && column.isNullable) {
                                 const nulls = await this.scalar(ctx, `SELECT COUNT(*) AS c FROM ${ctx.q(definition.tableName)} WHERE ${ctx.q(field.code)} IS NULL`);
-                                if (nulls > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.REQUIRED_HAS_NULLS */.Uu.REQUIRED_HAS_NULLS, {
+                                if (nulls > 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.REQUIRED_HAS_NULLS */.Uu.REQUIRED_HAS_NULLS, {
                                     field: field.code,
                                     count: nulls
                                 }));
@@ -4942,12 +5357,12 @@ class SchemaEvolutionService {
                 }
             }
             const manual = findings.filter((f)=>!f.repairable);
-            for (const f of manual)ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.NEEDS_MANUAL_ATTENTION */.Uu.NEEDS_MANUAL_ATTENTION, {
+            for (const f of manual)ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.NEEDS_MANUAL_ATTENTION */.Uu.NEEDS_MANUAL_ATTENTION, {
                 finding: (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(f.messageKey, f.messageVariables)
             }));
-            if (fixed.length === 0 && manual.length === 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_19/* .SCHEMA_WARNING_MESSAGES.NOTHING_TO_REPAIR */.Uu.NOTHING_TO_REPAIR));
+            if (fixed.length === 0 && manual.length === 0) ctx.warn((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_20/* .SCHEMA_WARNING_MESSAGES.NOTHING_TO_REPAIR */.Uu.NOTHING_TO_REPAIR));
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.REPAIR */.i.REPAIR,
+                operation: _enums_ddl_operation_enum_js__rspack_import_22/* .DdlOperation.REPAIR */.i.REPAIR,
                 diff: {
                     fixed,
                     manual: manual.length
@@ -4967,17 +5382,20 @@ SchemaEvolutionService = _ts_decorate([
         scope: _nestjs_common__rspack_import_2.Scope.REQUEST
     }),
     _ts_param(0, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_datasource_provider_js__rspack_import_10/* .EntityBuilderDataSourceProvider */.D)),
-    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_schema_dialect_adapter_service_js__rspack_import_18/* .SchemaDialectAdapterService */.I)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_schema_dialect_adapter_service_js__rspack_import_19/* .SchemaDialectAdapterService */.I)),
     _ts_param(2, (0,_nestjs_common__rspack_import_2.Inject)(_schema_change_executor_service_js__rspack_import_16/* .SchemaChangeExecutor */.T)),
     _ts_param(3, (0,_nestjs_common__rspack_import_2.Inject)(_reference_scanner_service_js__rspack_import_15/* .ReferenceScannerService */.t)),
     _ts_param(4, (0,_nestjs_common__rspack_import_2.Inject)(_entity_permission_service_js__rspack_import_11/* .EntityPermissionService */.u)),
+    _ts_param(5, (0,_nestjs_common__rspack_import_2.Optional)()),
+    _ts_param(5, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_config_service_js__rspack_import_18/* .EntityBuilderConfigService */.E)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _entity_builder_datasource_provider_js__rspack_import_10/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_10/* .EntityBuilderDataSourceProvider */.D,
-        typeof _schema_dialect_adapter_service_js__rspack_import_18/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_18/* .SchemaDialectAdapterService */.I,
+        typeof _schema_dialect_adapter_service_js__rspack_import_19/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_19/* .SchemaDialectAdapterService */.I,
         typeof _schema_change_executor_service_js__rspack_import_16/* .SchemaChangeExecutor */.T === "undefined" ? Object : _schema_change_executor_service_js__rspack_import_16/* .SchemaChangeExecutor */.T,
         typeof _reference_scanner_service_js__rspack_import_15/* .ReferenceScannerService */.t === "undefined" ? Object : _reference_scanner_service_js__rspack_import_15/* .ReferenceScannerService */.t,
-        typeof _entity_permission_service_js__rspack_import_11/* .EntityPermissionService */.u === "undefined" ? Object : _entity_permission_service_js__rspack_import_11/* .EntityPermissionService */.u
+        typeof _entity_permission_service_js__rspack_import_11/* .EntityPermissionService */.u === "undefined" ? Object : _entity_permission_service_js__rspack_import_11/* .EntityPermissionService */.u,
+        typeof _entity_builder_config_service_js__rspack_import_18/* .EntityBuilderConfigService */.E === "undefined" ? Object : _entity_builder_config_service_js__rspack_import_18/* .EntityBuilderConfigService */.E
     ])
 ], SchemaEvolutionService);
 
@@ -4994,13 +5412,13 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _flusys_nestjs_shared_utils__rspack_import_1 = __webpack_require__(9216);
 /* import */ var _nestjs_common__rspack_import_2 = __webpack_require__(6157);
 /* import */ var typeorm__rspack_import_3 = __webpack_require__(7158);
-/* import */ var _config_message_keys_js__rspack_import_17 = __webpack_require__(5732);
+/* import */ var _config_message_keys_js__rspack_import_18 = __webpack_require__(5732);
 /* import */ var _entities_entity_definition_entity_js__rspack_import_4 = __webpack_require__(3189);
 /* import */ var _entities_field_definition_entity_js__rspack_import_5 = __webpack_require__(2206);
 /* import */ var _entities_flow_definition_entity_js__rspack_import_6 = __webpack_require__(3770);
-/* import */ var _enums_ddl_operation_enum_js__rspack_import_20 = __webpack_require__(9949);
-/* import */ var _enums_entity_status_enum_js__rspack_import_21 = __webpack_require__(1313);
-/* import */ var _enums_field_type_enum_js__rspack_import_19 = __webpack_require__(9614);
+/* import */ var _enums_ddl_operation_enum_js__rspack_import_21 = __webpack_require__(9949);
+/* import */ var _enums_entity_status_enum_js__rspack_import_22 = __webpack_require__(1313);
+/* import */ var _enums_field_type_enum_js__rspack_import_20 = __webpack_require__(9614);
 /* import */ var _flow_engine_flow_errors_js__rspack_import_7 = __webpack_require__(8542);
 /* import */ var _entity_builder_datasource_provider_js__rspack_import_8 = __webpack_require__(424);
 /* import */ var _entity_flow_scaffold_js__rspack_import_9 = __webpack_require__(8271);
@@ -5010,7 +5428,8 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _identifier_rules_js__rspack_import_13 = __webpack_require__(413);
 /* import */ var _schema_change_executor_service_js__rspack_import_14 = __webpack_require__(6605);
 /* import */ var _schema_columns_js__rspack_import_15 = __webpack_require__(5313);
-/* import */ var _schema_dialect_adapter_service_js__rspack_import_16 = __webpack_require__(7259);
+/* import */ var _entity_builder_config_service_js__rspack_import_16 = __webpack_require__(4281);
+/* import */ var _schema_dialect_adapter_service_js__rspack_import_17 = __webpack_require__(7259);
 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") {
@@ -5054,6 +5473,7 @@ function _ts_param(paramIndex, decorator) {
 
 
 
+
 
 
 const presetId = (id)=>id ? {
@@ -5065,26 +5485,28 @@ class SchemaSyncService {
     executor;
     entityPermissionService;
     flowDefinitionService;
+    config;
     logger = new _nestjs_common__rspack_import_2.Logger(SchemaSyncService.name);
-    constructor(dataSourceProvider, dialectAdapter, executor, entityPermissionService, flowDefinitionService){
+    constructor(dataSourceProvider, dialectAdapter, executor, entityPermissionService, flowDefinitionService, config){
         this.dataSourceProvider = dataSourceProvider;
         this.dialectAdapter = dialectAdapter;
         this.executor = executor;
         this.entityPermissionService = entityPermissionService;
         this.flowDefinitionService = flowDefinitionService;
+        this.config = config;
     }
     validateCreateRequest(dto) {
-        (0,_identifier_rules_js__rspack_import_13/* .assertValidIdentifier */.kV)(dto.code, 'entity');
+        (0,_identifier_rules_js__rspack_import_13/* .assertValidIdentifier */.k)(dto.code, 'entity');
         const fields = dto.fields ?? [];
         for (const field of fields){
-            (0,_identifier_rules_js__rspack_import_13/* .assertValidIdentifier */.kV)(field.code, 'field');
-            (0,_identifier_rules_js__rspack_import_13/* .assertIndexableField */.fY)(field);
+            (0,_identifier_rules_js__rspack_import_13/* .assertValidIdentifier */.k)(field.code, 'field');
+            (0,_identifier_rules_js__rspack_import_13/* .assertIndexableField */.f)(field);
         }
         const duplicate = fields.map((f)=>f.code).find((code, index, all)=>all.indexOf(code) !== index);
         if (duplicate) {
             throw new _nestjs_common__rspack_import_2.BadRequestException({
                 message: `Field code '${duplicate}' is defined more than once.`,
-                messageKey: _config_message_keys_js__rspack_import_17/* .SCHEMA_MESSAGES.DUPLICATE_FIELD_CODE */.Hu.DUPLICATE_FIELD_CODE,
+                messageKey: _config_message_keys_js__rspack_import_18/* .SCHEMA_MESSAGES.DUPLICATE_FIELD_CODE */.Hu.DUPLICATE_FIELD_CODE,
                 messageVariables: {
                     code: duplicate
                 }
@@ -5113,7 +5535,7 @@ class SchemaSyncService {
             const taken = await ctx.qr.query((0,_flusys_nestjs_shared_classes__rspack_import_0.buildQuery)(`SELECT table_name FROM information_schema.tables WHERE table_schema = ${schemaExpr} AND table_name = ?`, ctx.driver), [
                 tableName
             ]);
-            if (taken.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.TABLE_EXISTS */.M3.TABLE_EXISTS, {
+            if (taken.length) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_BLOCKER_MESSAGES.TABLE_EXISTS */.M3.TABLE_EXISTS, {
                 table: tableName
             }));
             const definitions = ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_4/* .EntityDefinition */.f);
@@ -5122,12 +5544,12 @@ class SchemaSyncService {
                     code: dto.code
                 }
             });
-            if (known) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.ENTITY_CODE_EXISTS */.M3.ENTITY_CODE_EXISTS, {
+            if (known) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_BLOCKER_MESSAGES.ENTITY_CODE_EXISTS */.M3.ENTITY_CODE_EXISTS, {
                 code: dto.code
             }));
-            for (const spec of fieldSpecs.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_19/* .FieldType.RELATION */.P.RELATION)){
+            for (const spec of fieldSpecs.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION)){
                 if (!spec.relationTargetEntityId) {
-                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
+                    ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_BLOCKER_MESSAGES.RELATION_TARGET_REQUIRED */.M3.RELATION_TARGET_REQUIRED, {
                         field: spec.code
                     }));
                     continue;
@@ -5137,24 +5559,16 @@ class SchemaSyncService {
                         id: spec.relationTargetEntityId
                     }
                 });
-                if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.RELATION_FIELD_TARGET_MISSING */.M3.RELATION_FIELD_TARGET_MISSING, {
+                if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_BLOCKER_MESSAGES.RELATION_FIELD_TARGET_MISSING */.M3.RELATION_FIELD_TARGET_MISSING, {
                     field: spec.code
                 }));
             }
             const withDefault = fieldSpecs.filter((f)=>f.defaultValue !== undefined && f.defaultValue !== null);
-            const { errors: defaultErrors } = (0,_field_value_validator_js__rspack_import_11/* .validateRecord */.e)(withDefault.map((f)=>({
-                    code: f.code,
-                    label: f.label,
-                    fieldType: f.fieldType,
-                    nullable: true,
-                    defaultValue: null,
-                    selectOptions: f.selectOptions ?? null,
-                    validationRules: f.validationRules ?? null
-                })), Object.fromEntries(withDefault.map((f)=>[
+            const { errors: defaultErrors } = (0,_field_value_validator_js__rspack_import_11/* .validateRecord */.e)(withDefault.map(_field_value_validator_js__rspack_import_11/* .valueRulesOf */.C), Object.fromEntries(withDefault.map((f)=>[
                     f.code,
                     f.defaultValue
                 ])), 'insert');
-            for (const error of defaultErrors)ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
+            for (const error of defaultErrors)ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_BLOCKER_MESSAGES.DEFAULT_INVALID */.M3.DEFAULT_INVALID, {
                 problem: (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(error.messageKey, error.messageVariables)
             }));
             if (flowEndpoints.length) {
@@ -5165,15 +5579,14 @@ class SchemaSyncService {
                     },
                     where: {
                         slug
-                    },
-                    withDeleted: true
+                    }
                 });
-                if (clash) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.FLOW_SLUG_TAKEN */.M3.FLOW_SLUG_TAKEN, {
+                if (clash) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_BLOCKER_MESSAGES.FLOW_SLUG_TAKEN */.M3.FLOW_SLUG_TAKEN, {
                     slug
                 }));
             }
             if (ctx.blocked) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_20/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
                 diff: {}
             };
             const columns = fieldSpecs.map((spec)=>(0,_schema_columns_js__rspack_import_15/* .buildFieldColumn */.fu)({
@@ -5196,16 +5609,16 @@ class SchemaSyncService {
                     ...columns
                 ]
             });
-            await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_STEP_MESSAGES.CREATE_TABLE */.EQ.CREATE_TABLE, {
+            await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_STEP_MESSAGES.CREATE_TABLE */.EQ.CREATE_TABLE, {
                 table: tableName
             }), async ()=>{
                 await ctx.qr.createTable(table, false);
             });
-            for (const spec of fieldSpecs.filter((f)=>f.isIndexed && !f.unique)){
-                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
+            for (const spec of fieldSpecs.filter((f)=>(0,_schema_columns_js__rspack_import_15/* .indexedByDefault */.w5)(f) && !f.unique)){
+                await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
                     column: spec.code
                 }), async ()=>{
-                    await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_15/* .plainIndex */.v7)(tableName, spec.code, ctx.driver, this.dialectAdapter));
+                    await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_15/* .plainIndex */.v7)(tableName, spec.code, ctx.driver, this.dialectAdapter, isSoftDeleteEnabled && !!this.config?.isPartialIndexesEnabled()));
                 });
             }
             await ctx.metadata(async ()=>{
@@ -5216,7 +5629,7 @@ class SchemaSyncService {
                     label: dto.label,
                     description: dto.description ?? null,
                     tableName,
-                    status: _enums_entity_status_enum_js__rspack_import_21/* .EntityStatus.ACTIVE */.c.ACTIVE,
+                    status: _enums_entity_status_enum_js__rspack_import_22/* .EntityStatus.ACTIVE */.c.ACTIVE,
                     schemaVersion: 1,
                     isSoftDeleteEnabled,
                     isAuditEnabled,
@@ -5233,11 +5646,11 @@ class SchemaSyncService {
                             dbType: this.dialectAdapter.mapFieldType(spec.fieldType, ctx.driver),
                             nullable: spec.nullable ?? true,
                             unique: spec.unique ?? false,
-                            isIndexed: spec.isIndexed ?? false,
+                            isIndexed: (0,_schema_columns_js__rspack_import_15/* .indexedByDefault */.w5)(spec),
                             defaultValue: spec.defaultValue ?? null,
                             validationRules: spec.validationRules ?? null,
                             selectOptions: spec.selectOptions ?? null,
-                            relationTargetEntityId: spec.fieldType === _enums_field_type_enum_js__rspack_import_19/* .FieldType.RELATION */.P.RELATION ? spec.relationTargetEntityId : null,
+                            relationTargetEntityId: spec.fieldType === _enums_field_type_enum_js__rspack_import_20/* .FieldType.RELATION */.P.RELATION ? spec.relationTargetEntityId : null,
                             order: spec.order ?? index,
                             uiConfig: spec.uiConfig ?? null,
                             isSearchable: spec.isSearchable ?? false,
@@ -5248,7 +5661,7 @@ class SchemaSyncService {
                 created.definition = definition;
             });
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_20/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
+                operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
                 entityDefinitionId: created.definition?.id ?? null,
                 diff: {
                     fields: fieldSpecs.map((f)=>({
@@ -5284,7 +5697,7 @@ class SchemaSyncService {
         } catch (error) {
             this.logger.error(`The flow '${flow.slug}' of entity '${dto.code}' could not be created: ${error.message}`);
             return [
-                (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_17/* .SCHEMA_WARNING_MESSAGES.ENDPOINT_FLOW_FAILED */.Uu.ENDPOINT_FLOW_FAILED, {
+                (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_18/* .SCHEMA_WARNING_MESSAGES.ENDPOINT_FLOW_FAILED */.Uu.ENDPOINT_FLOW_FAILED, {
                     slug: flow.slug,
                     detail: (0,_flow_engine_flow_errors_js__rspack_import_7/* .errorRef */.O$)(error)
                 })
@@ -5307,10 +5720,10 @@ class SchemaSyncService {
         try {
             ({ plan: { warnings: planWarnings } } = await this.executor.apply(await this.createTarget(dto, user), this.createRun(dto, user, created, ids)));
         } catch (error) {
-            if (error instanceof _nestjs_common__rspack_import_2.ConflictException && error.getResponse().blockers?.some((b)=>b.messageKey === _config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.ENTITY_CODE_EXISTS */.M3.ENTITY_CODE_EXISTS || b.messageKey === _config_message_keys_js__rspack_import_17/* .SCHEMA_BLOCKER_MESSAGES.TABLE_EXISTS */.M3.TABLE_EXISTS)) {
+            if (error instanceof _nestjs_common__rspack_import_2.ConflictException && error.getResponse().blockers?.some((b)=>b.messageKey === _config_message_keys_js__rspack_import_18/* .SCHEMA_BLOCKER_MESSAGES.ENTITY_CODE_EXISTS */.M3.ENTITY_CODE_EXISTS || b.messageKey === _config_message_keys_js__rspack_import_18/* .SCHEMA_BLOCKER_MESSAGES.TABLE_EXISTS */.M3.TABLE_EXISTS)) {
                 throw new _nestjs_common__rspack_import_2.ConflictException({
                     message: `An entity with the code '${dto.code}' already exists.`,
-                    messageKey: _config_message_keys_js__rspack_import_17/* .ENTITY_DEFINITION_MESSAGES.CODE_ALREADY_EXISTS */.pL.CODE_ALREADY_EXISTS,
+                    messageKey: _config_message_keys_js__rspack_import_18/* .ENTITY_DEFINITION_MESSAGES.CODE_ALREADY_EXISTS */.pL.CODE_ALREADY_EXISTS,
                     messageVariables: {
                         code: dto.code
                     }
@@ -5332,17 +5745,20 @@ SchemaSyncService = _ts_decorate([
         scope: _nestjs_common__rspack_import_2.Scope.REQUEST
     }),
     _ts_param(0, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D)),
-    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_schema_dialect_adapter_service_js__rspack_import_17/* .SchemaDialectAdapterService */.I)),
     _ts_param(2, (0,_nestjs_common__rspack_import_2.Inject)(_schema_change_executor_service_js__rspack_import_14/* .SchemaChangeExecutor */.T)),
     _ts_param(3, (0,_nestjs_common__rspack_import_2.Inject)(_entity_permission_service_js__rspack_import_10/* .EntityPermissionService */.u)),
     _ts_param(4, (0,_nestjs_common__rspack_import_2.Inject)(_flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk)),
+    _ts_param(5, (0,_nestjs_common__rspack_import_2.Optional)()),
+    _ts_param(5, (0,_nestjs_common__rspack_import_2.Inject)(_entity_builder_config_service_js__rspack_import_16/* .EntityBuilderConfigService */.E)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D === "undefined" ? Object : _entity_builder_datasource_provider_js__rspack_import_8/* .EntityBuilderDataSourceProvider */.D,
-        typeof _schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_16/* .SchemaDialectAdapterService */.I,
+        typeof _schema_dialect_adapter_service_js__rspack_import_17/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_17/* .SchemaDialectAdapterService */.I,
         typeof _schema_change_executor_service_js__rspack_import_14/* .SchemaChangeExecutor */.T === "undefined" ? Object : _schema_change_executor_service_js__rspack_import_14/* .SchemaChangeExecutor */.T,
         typeof _entity_permission_service_js__rspack_import_10/* .EntityPermissionService */.u === "undefined" ? Object : _entity_permission_service_js__rspack_import_10/* .EntityPermissionService */.u,
-        typeof _flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk
+        typeof _flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk,
+        typeof _entity_builder_config_service_js__rspack_import_16/* .EntityBuilderConfigService */.E === "undefined" ? Object : _entity_builder_config_service_js__rspack_import_16/* .EntityBuilderConfigService */.E
     ])
 ], SchemaSyncService);