@flusys/nestjs-entity-builder 9.1.0-rc.1 → 9.1.1

package/fesm/{719.js → 870.js}

@@ -1,12 +1,1715 @@
-export const __rspack_esm_id = 719;
-export const __rspack_esm_ids = [719];
+export const __rspack_esm_id = 870;
+export const __rspack_esm_ids = [870];
 export const __webpack_modules__ = {
+6691(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_swagger__rspack_import_0 = __webpack_require__(6176);
+/* import */ var class_transformer__rspack_import_1 = __webpack_require__(5812);
+/* import */ var class_validator__rspack_import_2 = __webpack_require__(5421);
+/* import */ var _config_entity_builder_constants_js__rspack_import_4 = __webpack_require__(6576);
+/* import */ var _enums_entity_status_enum_js__rspack_import_6 = __webpack_require__(1313);
+/* import */ var _enums_field_type_enum_js__rspack_import_5 = __webpack_require__(9614);
+/* import */ var _flow_engine_flow_types_js__rspack_import_3 = __webpack_require__(6256);
+/* import */ var _interfaces_definition_bundle_interface_js__rspack_import_7 = __webpack_require__(8835);
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+
+
+
+
+
+const Nullable = ()=>(0,class_validator__rspack_import_2.ValidateIf)((_object, value)=>value !== null);
+class BundleFieldDto {
+    id;
+    code;
+    label;
+    fieldType;
+    nullable;
+    unique;
+    isIndexed;
+    defaultValue;
+    validationRules;
+    selectOptions;
+    relationTarget;
+    order;
+    uiConfig;
+    isSearchable;
+    deprecated;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsUUID)(),
+    _ts_metadata("design:type", String)
+], BundleFieldDto.prototype, "id", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.MaxLength)((/* inlined export .ENTITY_CODE_MAX_LENGTH */63)),
+    (0,class_validator__rspack_import_2.Matches)(_config_entity_builder_constants_js__rspack_import_4/* .ENTITY_CODE_PATTERN */.vs),
+    _ts_metadata("design:type", String)
+], BundleFieldDto.prototype, "code", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.IsNotEmpty)(),
+    (0,class_validator__rspack_import_2.MaxLength)(255),
+    _ts_metadata("design:type", String)
+], BundleFieldDto.prototype, "label", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        enum: _enums_field_type_enum_js__rspack_import_5/* .FieldType */.P
+    }),
+    (0,class_validator__rspack_import_2.IsEnum)(_enums_field_type_enum_js__rspack_import_5/* .FieldType */.P),
+    _ts_metadata("design:type", typeof _enums_field_type_enum_js__rspack_import_5/* .FieldType */.P === "undefined" ? Object : _enums_field_type_enum_js__rspack_import_5/* .FieldType */.P)
+], BundleFieldDto.prototype, "fieldType", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], BundleFieldDto.prototype, "nullable", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], BundleFieldDto.prototype, "unique", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], BundleFieldDto.prototype, "isIndexed", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)(),
+    (0,class_validator__rspack_import_2.Allow)(),
+    _ts_metadata("design:type", Object)
+], BundleFieldDto.prototype, "defaultValue", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        type: Object,
+        nullable: true
+    }),
+    Nullable(),
+    (0,class_validator__rspack_import_2.IsObject)(),
+    _ts_metadata("design:type", Object)
+], BundleFieldDto.prototype, "validationRules", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        type: [
+            Object
+        ],
+        nullable: true
+    }),
+    Nullable(),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    _ts_metadata("design:type", Object)
+], BundleFieldDto.prototype, "selectOptions", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Code of the entity a RELATION field points to',
+        nullable: true
+    }),
+    Nullable(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.Matches)(_config_entity_builder_constants_js__rspack_import_4/* .ENTITY_CODE_PATTERN */.vs),
+    _ts_metadata("design:type", Object)
+], BundleFieldDto.prototype, "relationTarget", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsInt)(),
+    (0,class_validator__rspack_import_2.Min)(0),
+    _ts_metadata("design:type", Number)
+], BundleFieldDto.prototype, "order", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        type: Object,
+        nullable: true
+    }),
+    Nullable(),
+    (0,class_validator__rspack_import_2.IsObject)(),
+    _ts_metadata("design:type", Object)
+], BundleFieldDto.prototype, "uiConfig", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], BundleFieldDto.prototype, "isSearchable", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], BundleFieldDto.prototype, "deprecated", void 0);
+class BundleEntityDto {
+    id;
+    code;
+    label;
+    description;
+    status;
+    isSoftDeleteEnabled;
+    isAuditEnabled;
+    uiConfig;
+    fields;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsUUID)(),
+    _ts_metadata("design:type", String)
+], BundleEntityDto.prototype, "id", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.MaxLength)((/* inlined export .ENTITY_CODE_MAX_LENGTH */63)),
+    (0,class_validator__rspack_import_2.Matches)(_config_entity_builder_constants_js__rspack_import_4/* .ENTITY_CODE_PATTERN */.vs),
+    _ts_metadata("design:type", String)
+], BundleEntityDto.prototype, "code", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.IsNotEmpty)(),
+    (0,class_validator__rspack_import_2.MaxLength)(255),
+    _ts_metadata("design:type", String)
+], BundleEntityDto.prototype, "label", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        nullable: true
+    }),
+    Nullable(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.MaxLength)(500),
+    _ts_metadata("design:type", Object)
+], BundleEntityDto.prototype, "description", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        enum: _enums_entity_status_enum_js__rspack_import_6/* .EntityStatus */.c
+    }),
+    (0,class_validator__rspack_import_2.IsEnum)(_enums_entity_status_enum_js__rspack_import_6/* .EntityStatus */.c),
+    _ts_metadata("design:type", typeof _enums_entity_status_enum_js__rspack_import_6/* .EntityStatus */.c === "undefined" ? Object : _enums_entity_status_enum_js__rspack_import_6/* .EntityStatus */.c)
+], BundleEntityDto.prototype, "status", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], BundleEntityDto.prototype, "isSoftDeleteEnabled", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], BundleEntityDto.prototype, "isAuditEnabled", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        type: Object,
+        nullable: true
+    }),
+    Nullable(),
+    (0,class_validator__rspack_import_2.IsObject)(),
+    _ts_metadata("design:type", Object)
+], BundleEntityDto.prototype, "uiConfig", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        type: [
+            BundleFieldDto
+        ]
+    }),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    (0,class_validator__rspack_import_2.ValidateNested)({
+        each: true
+    }),
+    (0,class_transformer__rspack_import_1.Type)(()=>BundleFieldDto),
+    _ts_metadata("design:type", Array)
+], BundleEntityDto.prototype, "fields", void 0);
+class BundleFlowDto {
+    name;
+    slug;
+    description;
+    isActive;
+    retainExecutions;
+    nodes;
+    edges;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.IsNotEmpty)(),
+    (0,class_validator__rspack_import_2.MaxLength)(255),
+    _ts_metadata("design:type", String)
+], BundleFlowDto.prototype, "name", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.Matches)(_flow_engine_flow_types_js__rspack_import_3/* .FLOW_SLUG_PATTERN */.YD),
+    _ts_metadata("design:type", String)
+], BundleFlowDto.prototype, "slug", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        nullable: true
+    }),
+    Nullable(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.MaxLength)(500),
+    _ts_metadata("design:type", Object)
+], BundleFlowDto.prototype, "description", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], BundleFlowDto.prototype, "isActive", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)(),
+    (0,class_validator__rspack_import_2.IsInt)(),
+    (0,class_validator__rspack_import_2.Min)(0),
+    (0,class_validator__rspack_import_2.Max)(10000),
+    _ts_metadata("design:type", Number)
+], BundleFlowDto.prototype, "retainExecutions", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        type: [
+            Object
+        ]
+    }),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    (0,class_validator__rspack_import_2.IsObject)({
+        each: true
+    }),
+    _ts_metadata("design:type", Array)
+], BundleFlowDto.prototype, "nodes", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        type: [
+            Object
+        ]
+    }),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    (0,class_validator__rspack_import_2.IsObject)({
+        each: true
+    }),
+    _ts_metadata("design:type", Array)
+], BundleFlowDto.prototype, "edges", void 0);
+class DefinitionBundleDto {
+    format;
+    version;
+    entities;
+    flows;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        example: _interfaces_definition_bundle_interface_js__rspack_import_7/* .DEFINITION_BUNDLE_FORMAT */.D
+    }),
+    (0,class_validator__rspack_import_2.Equals)(_interfaces_definition_bundle_interface_js__rspack_import_7/* .DEFINITION_BUNDLE_FORMAT */.D),
+    _ts_metadata("design:type", Object)
+], DefinitionBundleDto.prototype, "format", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        example: (/* inlined export .DEFINITION_BUNDLE_VERSION */1)
+    }),
+    (0,class_validator__rspack_import_2.Equals)((/* inlined export .DEFINITION_BUNDLE_VERSION */1)),
+    _ts_metadata("design:type", Object)
+], DefinitionBundleDto.prototype, "version", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        type: [
+            BundleEntityDto
+        ]
+    }),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    (0,class_validator__rspack_import_2.ValidateNested)({
+        each: true
+    }),
+    (0,class_transformer__rspack_import_1.Type)(()=>BundleEntityDto),
+    _ts_metadata("design:type", Array)
+], DefinitionBundleDto.prototype, "entities", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        type: [
+            BundleFlowDto
+        ]
+    }),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    (0,class_validator__rspack_import_2.ValidateNested)({
+        each: true
+    }),
+    (0,class_transformer__rspack_import_1.Type)(()=>BundleFlowDto),
+    _ts_metadata("design:type", Array)
+], DefinitionBundleDto.prototype, "flows", void 0);
+class ExportBundleDto {
+    entityCodes;
+    flowSlugs;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        type: [
+            String
+        ],
+        description: 'Entity codes to export (all when left out)'
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    (0,class_validator__rspack_import_2.ArrayUnique)(),
+    (0,class_validator__rspack_import_2.IsString)({
+        each: true
+    }),
+    _ts_metadata("design:type", Array)
+], ExportBundleDto.prototype, "entityCodes", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        type: [
+            String
+        ],
+        description: 'Flow slugs to export (every published flow when left out)'
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    (0,class_validator__rspack_import_2.ArrayUnique)(),
+    (0,class_validator__rspack_import_2.IsString)({
+        each: true
+    }),
+    _ts_metadata("design:type", Array)
+], ExportBundleDto.prototype, "flowSlugs", void 0);
+/** 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;
+    confirm;
+    expectedChecksum;
+    expectedPlanChecksum;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Deprecate fields this environment has and the bundle does not (their columns and data stay)',
+        default: false
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    FormBoolean(),
+    (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: 'apply-import: acknowledge steps that lose (or may lose) data',
+        default: false
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    FormBoolean(),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], ImportBundleOptionsDto.prototype, "confirm", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'apply-import: the checksum of the bundle that was reviewed; a different bundle is refused'
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.Matches)(/^[0-9a-f]{64}$/),
+    _ts_metadata("design:type", String)
+], ImportBundleOptionsDto.prototype, "expectedChecksum", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'apply-import: the planChecksum of the plan that was reviewed; a changed plan is refused, and it is required with confirm'
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    (0,class_validator__rspack_import_2.Matches)(/^[0-9a-f]{64}$/),
+    _ts_metadata("design:type", String)
+], ImportBundleOptionsDto.prototype, "expectedPlanChecksum", void 0);
+
+__webpack_require__.d(__webpack_exports__, {
+  JE: () => (DefinitionBundleDto),
+  KH: () => (BundleFlowDto),
+  QJ: () => (ExportBundleDto),
+  U3: () => (BundleFieldDto),
+  hX: () => (BundleEntityDto),
+  vS: () => (ImportBundleOptionsDto)
+});
+
+
+},
+8835(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+const DEFINITION_BUNDLE_FORMAT = 'flusys.entity-builder.bundle';
+const DEFINITION_BUNDLE_VERSION = 1;
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  D: DEFINITION_BUNDLE_FORMAT
+});
+
+
+},
 2492(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 const FLOW_REFERENCE_PROVIDER = 'FLOW_REFERENCE_PROVIDER';
 
 __webpack_require__.d(__webpack_exports__, {
-}, {
-  $: FLOW_REFERENCE_PROVIDER
+}, {
+  $: FLOW_REFERENCE_PROVIDER
+});
+
+
+},
+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);
+
+
+
+
+
+/** JSON with object keys sorted at every level: equal definitions always give the same text. */ function canonicalJson(value) {
+    return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+    if (Array.isArray(value)) return value.map(sortKeys);
+    if (value && typeof value === 'object' && !(value instanceof Date)) {
+        return Object.fromEntries(Object.keys(value).toSorted().filter((key)=>value[key] !== undefined).map((key)=>[
+                key,
+                sortKeys(value[key])
+            ]));
+    }
+    return value;
+}
+const same = (a, b)=>canonicalJson(a ?? null) === canonicalJson(b ?? null);
+/** Code-point order: the same in every locale, so exports and plans read the same everywhere. */ const byCode = (a, b)=>a < b ? -1 : a > b ? 1 : 0;
+/** What a step, extra or result is about: the flow slug, `entity.field` or the entity code. */ const bundleSubject = (item)=>item.flowSlug ?? (item.fieldCode ? `${item.entityCode}.${item.fieldCode}` : item.entityCode ?? '');
+const bundleChecksum = (bundle)=>(0,node_crypto__rspack_import_1.createHash)('sha256').update(canonicalJson(bundle)).digest('hex');
+// ── flows: API keys and environment variables ─────────────────────────────────────────
+/** Request steps without their API keys: a key belongs to one environment and is never promoted. */ function stripApiKeys(nodes) {
+    return nodes.map((node)=>{
+        if (node?.type !== 'trigger' || node.config?.['apiKey'] === undefined) return node;
+        const { apiKey: _apiKey, ...config } = node.config;
+        return {
+            ...node,
+            config
+        };
+    });
+}
+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)
+        } : 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).
+ */ function extractVariables(nodes, variables) {
+    const nameOf = new Map();
+    for (const [name, value] of Object.entries(variables).filter(([, text])=>typeof text === 'string' && text.length >= MIN_VARIABLE_VALUE_LENGTH).toSorted(([nameA, a], [nameB, b])=>b.length - a.length || byCode(nameA, nameB))){
+        if (!nameOf.has(value)) nameOf.set(value, name);
+    }
+    if (!nameOf.size) return nodes;
+    const pattern = new RegExp([
+        ...nameOf.keys()
+    ].map(escapeRegExp).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) {
+    const missing = new Set();
+    const resolved = mapConfigStrings(nodes, (text)=>text.replace(VARIABLE_PATTERN, (token, name)=>{
+            if (typeof variables[name] === 'string') return variables[name];
+            missing.add(name);
+            return token;
+        }));
+    return {
+        nodes: resolved,
+        missing: [
+            ...missing
+        ].toSorted(byCode)
+    };
+}
+/** 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']);
+}
+/** Called flows before their callers, so each Call flow step finds its flow published; otherwise by slug. */ function orderFlows(flows) {
+    const bySlug = new Map(flows.map((flow)=>[
+            flow.slug,
+            flow
+        ]));
+    const ordered = [];
+    const state = new Map();
+    const visit = (flow)=>{
+        if (state.has(flow.slug)) return;
+        state.set(flow.slug, 'visiting');
+        for (const slug of calledFlowSlugs(flow.nodes ?? []).toSorted(byCode)){
+            const callee = bySlug.get(slug);
+            if (callee) visit(callee);
+        }
+        state.set(flow.slug, 'done');
+        ordered.push(flow);
+    };
+    flows.toSorted((a, b)=>byCode(a.slug, b.slug)).forEach(visit);
+    return ordered;
+}
+const FIELD_COMPARED_KEYS = [
+    'label',
+    'fieldType',
+    'nullable',
+    'unique',
+    'isIndexed',
+    'defaultValue',
+    'validationRules',
+    'selectOptions',
+    'relationTarget',
+    'order',
+    'uiConfig',
+    'isSearchable'
+];
+const ENTITY_COMPARED_KEYS = [
+    'label',
+    'description',
+    'uiConfig',
+    'isSoftDeleteEnabled',
+    'isAuditEnabled',
+    'status'
+];
+function changedValues(from, to, keys) {
+    return Object.fromEntries(keys.filter((key)=>!same(from[key], to[key])).map((key)=>[
+            key,
+            to[key] ?? null
+        ]));
+}
+/**
+ * Pairs each item of the bundle with one of this environment's: by id first (a renamed one keeps
+ * its id), then by code among those no id claimed, so a rename never takes a field another item owns.
+ */ function matchDefinitions(items, current) {
+    const pairs = new Map();
+    const taken = new Set();
+    const claim = (item, hit)=>{
+        if (!hit) return;
+        pairs.set(item, hit);
+        taken.add(hit.id);
+    };
+    for (const item of items)claim(item, current.find((c)=>c.id === item.id && !taken.has(c.id)));
+    for (const item of items.filter((i)=>!pairs.has(i)))claim(item, current.find((c)=>c.code === item.code && !taken.has(c.id)));
+    return pairs;
+}
+/** The bundle's own problems: duplicates, and relations to an entity neither the bundle nor this environment has. */ function bundleProblems(entities, current) {
+    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, {
+            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, {
+            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, {
+                entity: entity.code,
+                field: field.code
+            }));
+            fieldCodes.add(field.code);
+            fieldIds.add(field.id);
+        }
+    }
+    const known = new Set([
+        ...codes,
+        ...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)){
+            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, {
+                    entity: entity.code,
+                    field: field.code,
+                    target: field.relationTarget ?? ''
+                }));
+            }
+        }
+    }
+    return problems;
+}
+/** A code no field of the entity has or gets, for the temporary step of a rename cycle. */ function temporaryCode(fieldId, taken) {
+    const base = `tmp_${fieldId.replace(/[^0-9a-z]/gi, '').toLowerCase().slice(0, 12)}`;
+    let code = base;
+    for(let n = 2; taken.has(code); n++)code = `${base}_${n}`;
+    taken.add(code);
+    return code;
+}
+/**
+ * Renames in an order that never takes a code another field still has: a rename waits for the one
+ * that frees its new code (a -> b after b -> c), and a cycle (a <-> b) goes through a temporary code
+ * first (a -> tmp, b -> a, tmp -> b). Each rename rewrites the references to its field, so the
+ * references end up exactly where the bundle has them.
+ */ function orderRenames(entityCode, renames, taken) {
+    const ordered = [];
+    const pending = renames.map((rename)=>({
+            ...rename,
+            waited: false
+        })).toSorted((a, b)=>byCode(a.from, b.from));
+    const step = (rename, from, to, dependsOnEarlierStep, warnings)=>({
+            kind: 'rename_field',
+            entityCode,
+            fieldCode: from,
+            targetFieldId: rename.targetFieldId,
+            details: {
+                from,
+                to
+            },
+            dependsOnEarlierStep,
+            changes: {
+                code: to
+            },
+            ...warnings ? {
+                warnings
+            } : {}
+        });
+    while(pending.length){
+        const ready = pending.filter((rename)=>!pending.some((other)=>other !== rename && other.from === rename.to));
+        if (ready.length) {
+            for (const rename of ready){
+                ordered.push(step(rename, rename.from, rename.to, rename.restored || rename.waited));
+                pending.splice(pending.indexOf(rename), 1);
+            }
+            for (const rename of pending)rename.waited = true;
+            continue;
+        }
+        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, {
+                field: first.from,
+                temporary,
+                to: first.to
+            })
+        ]));
+        const freed = pending.find((rename)=>rename.to === first.from);
+        if (freed) freed.waited = true;
+        first.from = temporary;
+        first.waited = true;
+    }
+    return ordered;
+}
+/**
+ * What it takes to bring this environment's entities to the bundle's. Entities and fields are
+ * matched by id first (a field renamed where it was designed keeps its id), then by code. Nothing
+ * the bundle lacks is removed: such definitions are reported as extras, and only with
+ * `deprecateMissingFields` are missing fields deprecated (which keeps their column and data).
+ *
+ * Order: entities switched back on, new entities (their relation fields wait until every new entity
+ * exists), field changes of existing entities (per entity: restores, renames, changes, new fields,
+ * deprecations), the new entities' relation fields, and entities switched off last. A DRAFT entity
+ * (no table) on either side blocks the import.
+ */ function diffEntities(entities, current, options = {}) {
+    const result = {
+        operations: [],
+        unchangedEntities: 0,
+        unchangedFields: 0,
+        extras: [],
+        blockers: bundleProblems(entities, current)
+    };
+    const entityUpdatesFirst = [];
+    const creates = [];
+    const fieldOps = [];
+    const relationAdds = [];
+    const entityUpdatesLast = [];
+    const sorted = entities.toSorted((a, b)=>byCode(a.code, b.code));
+    const pairs = matchDefinitions(sorted, current);
+    const matched = new Set([
+        ...pairs.values()
+    ].map((e)=>e.id));
+    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, {
+                entity: entity.code,
+                current: target.code
+            }));
+            continue;
+        }
+        if (!target) {
+            const live = entity.fields.filter((f)=>!f.deprecated);
+            creates.push({
+                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)
+                },
+                dependsOnEarlierStep: false,
+                entity: {
+                    ...entity,
+                    fields: 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_4/* .FieldType.RELATION */.P.RELATION)){
+                relationAdds.push({
+                    kind: 'add_field',
+                    entityCode: entity.code,
+                    fieldCode: field.code,
+                    details: {
+                        fieldType: field.fieldType,
+                        relationTarget: field.relationTarget
+                    },
+                    dependsOnEarlierStep: true,
+                    field
+                });
+            }
+            if (entity.status === _enums_entity_status_enum_js__rspack_import_3/* .EntityStatus.DEPRECATED */.c.DEPRECATED) {
+                entityUpdatesLast.push({
+                    kind: 'update_entity',
+                    entityCode: entity.code,
+                    details: {
+                        changes: [
+                            'status'
+                        ]
+                    },
+                    dependsOnEarlierStep: true,
+                    changes: {
+                        status: _enums_entity_status_enum_js__rspack_import_3/* .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, {
+                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;
+        if (Object.keys(entityChanges).length) {
+            (deprecating ? entityUpdatesLast : entityUpdatesFirst).push({
+                kind: 'update_entity',
+                entityCode: entity.code,
+                details: {
+                    changes: Object.keys(entityChanges)
+                },
+                dependsOnEarlierStep: false,
+                changes: entityChanges
+            });
+        } else {
+            result.unchangedEntities++;
+        }
+        const fields = entity.fields.toSorted((a, b)=>a.order - b.order || byCode(a.code, b.code));
+        const fieldPairs = matchDefinitions(fields, target.fields);
+        const usedFieldIds = new Set([
+            ...fieldPairs.values()
+        ].map((f)=>f.id));
+        const restores = [];
+        const renames = [];
+        const updates = [];
+        const adds = [];
+        const deprecations = [];
+        for (const field of fields){
+            const existing = fieldPairs.get(field);
+            if (!existing) {
+                if (field.deprecated) continue;
+                adds.push({
+                    kind: 'add_field',
+                    entityCode: entity.code,
+                    fieldCode: field.code,
+                    details: {
+                        fieldType: field.fieldType,
+                        relationTarget: field.relationTarget
+                    },
+                    dependsOnEarlierStep: false,
+                    field
+                });
+                continue;
+            }
+            const at = {
+                entityCode: entity.code,
+                targetFieldId: existing.id
+            };
+            let touched = false;
+            // A deprecated field cannot be changed until it is restored; a rename does not stop the other changes from being previewed.
+            const restored = existing.deprecated && !field.deprecated;
+            if (restored) {
+                restores.push({
+                    ...at,
+                    kind: 'restore_field',
+                    fieldCode: existing.code,
+                    details: {},
+                    dependsOnEarlierStep: false
+                });
+                touched = true;
+            }
+            if (existing.code !== field.code && !field.deprecated) {
+                renames.push({
+                    targetFieldId: existing.id,
+                    from: existing.code,
+                    to: field.code,
+                    restored
+                });
+                touched = true;
+            }
+            const changes = field.deprecated ? {} : changedValues(existing, field, FIELD_COMPARED_KEYS);
+            if (Object.keys(changes).length) {
+                updates.push({
+                    ...at,
+                    kind: 'update_field',
+                    fieldCode: field.code,
+                    details: {
+                        changes: Object.keys(changes)
+                    },
+                    dependsOnEarlierStep: restored,
+                    changes
+                });
+                touched = true;
+            }
+            if (field.deprecated && !existing.deprecated) {
+                deprecations.push({
+                    ...at,
+                    kind: 'deprecate_field',
+                    fieldCode: existing.code,
+                    details: {},
+                    dependsOnEarlierStep: false
+                });
+                touched = true;
+            }
+            if (!touched) result.unchangedFields++;
+        }
+        // A new field may take a code a rename frees: it is added once that rename has run.
+        const freedCodes = new Set(renames.map((r)=>r.from));
+        for (const add of adds)if (freedCodes.has(add.fieldCode)) add.dependsOnEarlierStep = true;
+        const takenCodes = new Set([
+            ...target.fields.map((f)=>f.code),
+            ...fields.map((f)=>f.code)
+        ]);
+        fieldOps.push(...restores, ...orderRenames(entity.code, renames, takenCodes), ...updates, ...adds, ...deprecations);
+        for (const extra of target.fields.filter((f)=>!usedFieldIds.has(f.id) && !f.deprecated)){
+            if (options.deprecateMissingFields) {
+                fieldOps.push({
+                    kind: 'deprecate_field',
+                    entityCode: entity.code,
+                    fieldCode: extra.code,
+                    targetFieldId: extra.id,
+                    details: {},
+                    dependsOnEarlierStep: false
+                });
+            } else {
+                result.extras.push({
+                    kind: 'field',
+                    entityCode: entity.code,
+                    fieldCode: extra.code
+                });
+            }
+        }
+    }
+    for (const extra of current.filter((e)=>!matched.has(e.id)))result.extras.push({
+        kind: 'entity',
+        entityCode: extra.code
+    });
+    result.operations = [
+        ...entityUpdatesFirst,
+        ...creates,
+        ...fieldOps,
+        ...relationAdds,
+        ...entityUpdatesLast
+    ];
+    return result;
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  Og: () => (matchDefinitions),
+  Q5: () => (calledFlowSlugs),
+  dX: () => (stripApiKeys),
+  dj: () => (canonicalJson),
+  gT: () => (applyVariables),
+  lj: () => (extractVariables),
+  qG: () => (orderFlows),
+  zb: () => (diffEntities)
+}, {
+  $I: ENTITY_COMPARED_KEYS,
+  VU: byCode,
+  bs: bundleSubject,
+  i9: bundleChecksum,
+  mT: FIELD_COMPARED_KEYS
+});
+
+
+},
+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);
+
+
+
+
+
+const MAX_REPORTED_PROBLEMS = 50;
+/** Every failed constraint, named by its path in the bundle (`entities.0.fields.2.code`). */ 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('; ')
+            }
+        ] : [];
+        return [
+            ...own,
+            ...problems(error.children ?? [], field)
+        ];
+    });
+}
+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,
+        ...errors.length ? {
+            errors: errors.slice(0, MAX_REPORTED_PROBLEMS)
+        } : {}
+    });
+/**
+ * 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) {
+    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
+        });
+    }
+    let raw;
+    try {
+        raw = JSON.parse(file.buffer.toString('utf8').replace(/^\uFEFF/, ''));
+    } catch  {
+        throw invalid();
+    }
+    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, {
+        whitelist: true,
+        forbidNonWhitelisted: true
+    });
+    if (errors.length) throw invalid(problems(errors));
+    return bundle;
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  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);
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/** 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 [];
+    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));
+}
+/** 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',
+    'nullable',
+    'unique'
+];
+const LOSSY_ENTITY_CHANGES = [
+    'isSoftDeleteEnabled',
+    'isAuditEnabled'
+];
+function mayLoseData(step) {
+    const changes = Array.isArray(step.details['changes']) ? step.details['changes'] : [];
+    if (step.kind === 'update_field') return changes.some((c)=>LOSSY_FIELD_CHANGES.includes(c));
+    return step.kind === 'update_entity' && changes.some((c)=>LOSSY_ENTITY_CHANGES.includes(c));
+}
+/**
+ * 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) {
+    const reviewed = steps.map((step)=>({
+            kind: step.kind,
+            subject: (0,_definition_bundle_diff_js__rspack_import_10/* .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)({
+        bundle,
+        deprecateMissingFields,
+        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;
+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();
+    for (const node of [
+        ...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']);
+    }
+    return keys;
+}
+class DefinitionBundleService {
+    provider;
+    config;
+    schemaSync;
+    evolution;
+    flows;
+    constructor(provider, config, schemaSync, evolution, flows){
+        this.provider = provider;
+        this.config = config;
+        this.schemaSync = schemaSync;
+        this.evolution = evolution;
+        this.flows = flows;
+    }
+    variables() {
+        return this.config.getBundleVariables();
+    }
+    // ── 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)=>({
+                ...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))
+            }));
+        const flowRepo = await this.provider.getRepository(_entities_flow_definition_entity_js__rspack_import_7/* .FlowDefinition */.G);
+        const rows = (await flowRepo.find({
+            where: dto.flowSlugs ? {
+                slug: (0,typeorm__rspack_import_3.In)(dto.flowSlugs)
+            } : {}
+        })).toSorted((a, b)=>(0,_definition_bundle_diff_js__rspack_import_10/* .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, {
+                    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, {
+                    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);
+            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),
+                edges: snapshot.edges ?? []
+            };
+        });
+        // 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,
+            version: (/* inlined export .DEFINITION_BUNDLE_VERSION */1),
+            entities,
+            flows
+        }));
+        return {
+            bundle,
+            checksum: (0,_definition_bundle_diff_js__rspack_import_10/* .bundleChecksum */.i9)(bundle),
+            warnings
+        };
+    }
+    /** 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 codeOf = new Map(definitions.map((d)=>[
+                d.id,
+                d.code
+            ]));
+        return definitions.map((definition)=>({
+                id: definition.id,
+                code: definition.code,
+                label: definition.label,
+                description: definition.description ?? null,
+                status: definition.status,
+                isSoftDeleteEnabled: definition.isSoftDeleteEnabled,
+                isAuditEnabled: definition.isAuditEnabled,
+                uiConfig: definition.uiConfig ?? null,
+                fields: fields.filter((f)=>f.entityDefinitionId === definition.id && !f.isSystemField).map((f)=>({
+                        id: f.id,
+                        code: f.code,
+                        label: f.label,
+                        fieldType: f.fieldType,
+                        nullable: f.nullable,
+                        unique: f.unique,
+                        isIndexed: f.isIndexed,
+                        defaultValue: f.defaultValue ?? null,
+                        validationRules: f.validationRules ?? null,
+                        selectOptions: f.selectOptions ?? null,
+                        relationTarget: f.relationTargetEntityId ? codeOf.get(f.relationTargetEntityId) ?? null : null,
+                        order: f.order,
+                        uiConfig: f.uiConfig ?? null,
+                        isSearchable: f.isSearchable,
+                        deprecated: !!f.deprecatedAt
+                    }))
+            }));
+    }
+    // ── plan ────────────────────────────────────────────────────────────────────────────
+    async planImport(dto, user) {
+        const { plan } = await this.buildPlan(dto, user);
+        return plan;
+    }
+    /** 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, {
+            deprecateMissingFields: dto.deprecateMissingFields === true
+        });
+        const flowDiff = await this.diffFlows(bundle.flows);
+        const existingCodes = new Set(current.map((e)=>e.code));
+        const steps = [];
+        for (const operation of entityDiff.operations){
+            const dependent = operation.dependsOnEarlierStep || operation.kind !== 'create_entity' && !existingCodes.has(operation.entityCode) || this.relationNotYetCreated(operation, existingCodes);
+            const step = {
+                kind: operation.kind,
+                entityCode: operation.entityCode,
+                ...operation.fieldCode ? {
+                    fieldCode: operation.fieldCode
+                } : {},
+                details: operation.details,
+                preview: null,
+                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)
+                    ] : []
+                ],
+                blockers: []
+            };
+            if (!dependent) {
+                try {
+                    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));
+                }
+            }
+            steps.push(step);
+        }
+        const schemaChanges = entityDiff.operations.length > 0;
+        const importedSlugs = new Set(flowDiff.planned.map((p)=>p.flow.slug));
+        for (const planned of flowDiff.planned){
+            const step = {
+                kind: planned.kind,
+                flowSlug: planned.flow.slug,
+                details: planned.details,
+                preview: null,
+                warnings: [
+                    ...planned.warnings
+                ],
+                blockers: [
+                    ...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 (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));
+            } else if (!step.blockers.length) {
+                const { errors, warnings } = await this.flows.validate((0,_flow_definition_service_js__rspack_import_13/* .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);
+        const plan = {
+            checksum,
+            planChecksum: planChecksum(checksum, dto.deprecateMissingFields === true, steps),
+            steps,
+            unchanged: {
+                entities: entityDiff.unchangedEntities,
+                fields: entityDiff.unchangedFields,
+                flows: flowDiff.unchanged
+            },
+            extras: [
+                ...entityDiff.extras,
+                ...flowDiff.extras
+            ],
+            blockers: [
+                ...entityDiff.blockers,
+                ...flowDiff.blockers
+            ],
+            destructive: steps.some((s)=>s.preview?.destructive),
+            mayLoseData: steps.some((s)=>s.preview?.destructive || !s.preview && mayLoseData(s))
+        };
+        return {
+            plan,
+            operations: entityDiff.operations,
+            flows: flowDiff.planned
+        };
+    }
+    /** 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);
+    }
+    async previewEntityStep(operation, current, user) {
+        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);
+        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 result = {
+            planned: [],
+            unchanged: 0,
+            extras: [],
+            blockers: []
+        };
+        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, {
+                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);
+            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, {
+                    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, {
+                    flow: flow.slug,
+                    path: triggerPath(node) ?? ''
+                }));
+            if (!target) {
+                result.planned.push({
+                    kind: 'create_flow',
+                    flow,
+                    existingId: null,
+                    details: {},
+                    warnings,
+                    blockers
+                });
+                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) {
+                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, {
+                flow: flow.slug
+            }));
+            result.planned.push({
+                kind: 'update_flow',
+                flow,
+                existingId: target.id,
+                details: {
+                    changes: changed
+                },
+                warnings,
+                blockers
+            });
+        }
+        for (const extra of existing.filter((flow)=>!seen.has(flow.slug)))result.extras.push({
+            kind: 'flow',
+            flowSlug: extra.slug
+        });
+        return result;
+    }
+    // ── requests for the designer's services ────────────────────────────────────────────
+    fieldSpec(field, relationTargetEntityId) {
+        return {
+            code: field.code,
+            label: field.label,
+            fieldType: field.fieldType,
+            nullable: field.nullable,
+            unique: field.unique,
+            isIndexed: field.isIndexed,
+            defaultValue: field.defaultValue ?? undefined,
+            validationRules: field.validationRules ?? undefined,
+            selectOptions: field.selectOptions ?? undefined,
+            order: field.order,
+            uiConfig: field.uiConfig ?? undefined,
+            isSearchable: field.isSearchable,
+            ...relationTargetEntityId ? {
+                relationTargetEntityId
+            } : {}
+        };
+    }
+    createRequest(entity) {
+        return {
+            code: entity.code,
+            label: entity.label,
+            description: entity.description ?? undefined,
+            isSoftDeleteEnabled: entity.isSoftDeleteEnabled,
+            isAuditEnabled: entity.isAuditEnabled,
+            uiConfig: entity.uiConfig ?? undefined,
+            fields: entity.fields.map((field)=>this.fieldSpec(field))
+        };
+    }
+    /** The schema change for one step, with this environment's ids (looked up now: earlier steps may have created them). */ changeRequest(operation, current) {
+        const entity = current.find((e)=>e.code === operation.entityCode);
+        const idOf = (code)=>code ? current.find((e)=>e.code === code)?.id : undefined;
+        switch(operation.kind){
+            case 'add_field':
+                return {
+                    action: _dtos_schema_change_dto_js__rspack_import_4/* .SchemaChangeAction.ADD_FIELD */.M3.ADD_FIELD,
+                    entityDefinitionId: entity?.id,
+                    field: this.fieldSpec(operation.field, idOf(operation.field.relationTarget))
+                };
+            case 'rename_field':
+            case 'update_field':
+                {
+                    const { relationTarget, ...changes } = operation.changes ?? {};
+                    if (relationTarget !== undefined) Object.assign(changes, {
+                        relationTargetEntityId: idOf(relationTarget) ?? null
+                    });
+                    return {
+                        action: _dtos_schema_change_dto_js__rspack_import_4/* .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,
+                    fieldDefinitionId: operation.targetFieldId
+                };
+            case 'restore_field':
+                return {
+                    action: _dtos_schema_change_dto_js__rspack_import_4/* .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,
+                    entityDefinitionId: entity?.id,
+                    changes: operation.changes
+                };
+        }
+    }
+    // ── apply ───────────────────────────────────────────────────────────────────────────
+    async applyImport(dto, user) {
+        const checksum = (0,_definition_bundle_diff_js__rspack_import_10/* .bundleChecksum */.i9)(dto.bundle);
+        if (dto.expectedChecksum && dto.expectedChecksum !== checksum) {
+            throw new _nestjs_common__rspack_import_1.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,
+                messageVariables: {
+                    checksum
+                }
+            });
+        }
+        const { plan, operations, flows } = await this.buildPlan(dto, user);
+        if (dto.expectedPlanChecksum && dto.expectedPlanChecksum !== plan.planChecksum) {
+            throw new _nestjs_common__rspack_import_1.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,
+                messageVariables: {
+                    planChecksum: plan.planChecksum
+                }
+            });
+        }
+        // `errors` is what the global exception filter passes on, so the caller sees every reason.
+        const blockers = [
+            ...plan.blockers.map((b)=>({
+                    field: 'bundle',
+                    ...b
+                })),
+            ...plan.steps.flatMap((s)=>s.blockers.map((b)=>({
+                        field: (0,_definition_bundle_diff_js__rspack_import_10/* .bundleSubject */.bs)(s),
+                        ...b
+                    })))
+        ];
+        if (blockers.length) {
+            throw new _nestjs_common__rspack_import_1.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,
+                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
+                }));
+            throw new _nestjs_common__rspack_import_1.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,
+                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({
+                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
+            });
+        }
+        const result = {
+            checksum: plan.checksum,
+            completed: true,
+            steps: [],
+            apiKeys: [],
+            warnings: plan.steps.flatMap((s)=>s.warnings)
+        };
+        const note = `Imported from bundle ${plan.checksum.slice(0, 12)}`;
+        const run = async (step, fn)=>{
+            if (!result.completed) return result.steps.push({
+                ...step,
+                status: 'skipped'
+            });
+            try {
+                await fn();
+                result.steps.push({
+                    ...step,
+                    status: 'applied'
+                });
+            } catch (error) {
+                result.completed = false;
+                const reasons = failureDetails(error);
+                result.steps.push({
+                    ...step,
+                    status: 'failed',
+                    error: (0,_flow_engine_flow_errors_js__rspack_import_8/* .errorRef */.O$)(error),
+                    ...reasons.length ? {
+                        blockers: reasons
+                    } : {}
+                });
+            }
+        };
+        // Entity codes and field ids never change during an import: only a created entity adds ids to look up.
+        let current = await this.loadEntities();
+        for (const operation of operations){
+            await run({
+                kind: operation.kind,
+                entityCode: operation.entityCode,
+                ...operation.fieldCode ? {
+                    fieldCode: operation.fieldCode
+                } : {}
+            }, ()=>this.applyEntityStep(operation, current, dto.confirm === true, user));
+            if (operation.kind === 'create_entity' && result.completed) current = await this.loadEntities();
+        }
+        for (const planned of flows){
+            await run({
+                kind: planned.kind,
+                flowSlug: planned.flow.slug
+            }, ()=>this.applyFlowStep(planned, note, result.apiKeys, user));
+        }
+        return result;
+    }
+    async applyEntityStep(operation, current, confirm, user) {
+        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,
+                fieldIds: Object.fromEntries(await this.freeFieldIds(entity.fields))
+            });
+            return;
+        }
+        const request = {
+            ...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;
+        await this.evolution.apply(request, user, {
+            fieldId
+        });
+    }
+    async idIsFree(entity, id) {
+        return !await (await this.provider.getRepository(entity)).exists({
+            where: {
+                id
+            },
+            withDeleted: true
+        });
+    }
+    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({
+            select: {
+                id: true
+            },
+            where: {
+                id: (0,typeorm__rspack_import_3.In)(fields.map((f)=>f.id))
+            },
+            withDeleted: true
+        })).map((f)=>f.id));
+        return fields.filter((f)=>!taken.has(f.id)).map((f)=>[
+                f.code,
+                f.id
+            ]);
+    }
+    /** 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) {
+        const existing = planned.existingId ? await this.flows.findOrFail(planned.existingId) : undefined;
+        const keys = storedApiKeys(existing);
+        const generated = [];
+        const nodes = planned.flow.nodes.map((node)=>{
+            if (!needsApiKey(node)) return node;
+            const stored = keys.get(node.id);
+            if (stored) return {
+                ...node,
+                config: {
+                    ...node.config,
+                    apiKey: stored
+                }
+            };
+            const key = newApiKey();
+            generated.push({
+                flowSlug: planned.flow.slug,
+                nodeId: node.id,
+                path: triggerPath(node),
+                key
+            });
+            return {
+                ...node,
+                config: {
+                    ...node.config,
+                    apiKey: key
+                }
+            };
+        });
+        const values = {
+            ...planned.flow,
+            description: planned.flow.description ?? undefined,
+            nodes
+        };
+        const id = existing ? (await this.flows.update({
+            ...values,
+            id: existing.id
+        }, user), existing.id) : (await this.flows.insert(values, user)).id;
+        // Saved: these keys are stored now, so they are answered even if publishing fails (the next import reuses them).
+        apiKeys.push(...generated);
+        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
+    }),
+    _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_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
+    ])
+], DefinitionBundleService);
+
+__webpack_require__.d(__webpack_exports__, {
+  P: () => (DefinitionBundleService)
 });
 
 
@@ -147,13 +1850,17 @@ __webpack_require__.d(__webpack_exports__, {
 
 },
 8271(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _config_message_keys_js__rspack_import_2 = __webpack_require__(5732);
-/* import */ var _enums_field_type_enum_js__rspack_import_1 = __webpack_require__(9614);
-/* import */ var _flow_engine_flow_types_js__rspack_import_0 = __webpack_require__(6256);
+/* import */ var _flusys_nestjs_shared_constants__rspack_import_0 = __webpack_require__(9140);
+/* import */ var _config_message_keys_js__rspack_import_4 = __webpack_require__(5732);
+/* import */ var _enums_field_type_enum_js__rspack_import_2 = __webpack_require__(9614);
+/* import */ var _flow_engine_flow_permission_logic_js__rspack_import_3 = __webpack_require__(8220);
+/* import */ var _flow_engine_flow_types_js__rspack_import_1 = __webpack_require__(6256);
+
 
 
 
-const SLUG_SUFFIX = {
+
+/** The path of each endpoint's Request step: `api-flows/<entity>/<path>`. */ const ENTITY_FLOW_PATHS = {
     insert: 'insert',
     insertMany: 'insert-many',
     getById: 'get-by-id',
@@ -165,7 +1872,7 @@ const SLUG_SUFFIX = {
     bulkUpsert: 'bulk-upsert',
     delete: 'delete'
 };
-const DEFAULT_FLOW_NAME = {
+const DEFAULT_ENDPOINT_NAME = {
     insert: 'Insert',
     insertMany: 'Insert many',
     getById: 'Get by id',
@@ -183,26 +1890,71 @@ const DEFAULT_INPUT_LABEL = {
     search: 'Search'
 };
 const DEFAULT_NO_MATCH_MESSAGE = 'No record matches the filter.';
-const MAX_FLOW_NAME_LENGTH = 255;
+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 = {
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.TEXT */.P.TEXT]: 'string',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.LONG_TEXT */.P.LONG_TEXT]: 'text',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.INTEGER */.P.INTEGER]: 'integer',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.DECIMAL */.P.DECIMAL]: 'number',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.BOOLEAN */.P.BOOLEAN]: 'boolean',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.DATE */.P.DATE]: 'date',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.DATETIME */.P.DATETIME]: 'datetime',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.EMAIL */.P.EMAIL]: 'email',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT]: 'choice',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT]: 'array',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.RELATION */.P.RELATION]: 'uuid',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.JSON */.P.JSON]: 'object',
-    [_enums_field_type_enum_js__rspack_import_1/* .FieldType.FILE */.P.FILE]: 'string'
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.TEXT */.P.TEXT]: 'string',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.LONG_TEXT */.P.LONG_TEXT]: 'text',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.INTEGER */.P.INTEGER]: 'integer',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.DECIMAL */.P.DECIMAL]: 'number',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.BOOLEAN */.P.BOOLEAN]: 'boolean',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.DATE */.P.DATE]: 'date',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.DATETIME */.P.DATETIME]: 'datetime',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.EMAIL */.P.EMAIL]: 'email',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.SINGLE_SELECT */.P.SINGLE_SELECT]: 'choice',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT]: 'array',
+    [_enums_field_type_enum_js__rspack_import_2/* .FieldType.RELATION */.P.RELATION]: 'uuid',
+    [_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 MAX_SLUG_LENGTH = 63;
 const LIST_LIMIT = 50;
-/** A bulk flow runs up to three steps per item (bulkUpsert: check, write, keep), well inside FLOW_LIMITS.MAX_STEPS_PER_RUN. */ const BULK_MAX_ITEMS = 200;
+const READ_ENDPOINTS = new Set([
+    'getById',
+    'getByIds',
+    'getAll',
+    'getByFilter'
+]);
+/** The entity permissions each endpoint asks for - the ones created with the entity; an upsert may create and update. */ const ENDPOINT_ACTIONS = {
+    insert: [
+        'create'
+    ],
+    insertMany: [
+        'create'
+    ],
+    getById: [
+        'read'
+    ],
+    getByIds: [
+        'read'
+    ],
+    getAll: [
+        'read'
+    ],
+    getByFilter: [
+        'read'
+    ],
+    update: [
+        'update'
+    ],
+    updateMany: [
+        'update'
+    ],
+    bulkUpsert: [
+        'create',
+        'update'
+    ],
+    delete: [
+        'delete'
+    ]
+};
+function endpointPermissions(entityCode, endpoint) {
+    const actions = ENDPOINT_ACTIONS[endpoint].map((action)=>(0,_flow_engine_flow_permission_logic_js__rspack_import_3/* .permissionAction */.s)((0,_flusys_nestjs_shared_constants__rspack_import_0.dynamicEntityPermission)(entityCode, action)));
+    return actions.length === 1 ? actions[0] : {
+        type: 'group',
+        operator: 'AND',
+        children: actions
+    };
+}
 const COLUMN = {
     x: 40,
     gap: 300
@@ -219,24 +1971,60 @@ const lit = (value)=>({
         type: 'literal',
         value
     });
-/** `customer_ticket` + getAll -> `customer-ticket-get-all`, shortened so it always fits the slug length. */ function entityFlowSlug(entityCode, endpoint) {
-    const suffix = SLUG_SUFFIX[endpoint];
-    const base = entityCode.replace(/_/g, '-').slice(0, MAX_SLUG_LENGTH - suffix.length - 1).replace(/-+$/, '');
-    return `${base}-${suffix}`;
-}
+/** `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));
 }
-function fieldInput(field, required) {
+const NUMERIC_TYPES = new Set([
+    _enums_field_type_enum_js__rspack_import_2/* .FieldType.INTEGER */.P.INTEGER,
+    _enums_field_type_enum_js__rspack_import_2/* .FieldType.DECIMAL */.P.DECIMAL
+]);
+const TEXT_TYPES = new Set([
+    _enums_field_type_enum_js__rspack_import_2/* .FieldType.TEXT */.P.TEXT,
+    _enums_field_type_enum_js__rspack_import_2/* .FieldType.LONG_TEXT */.P.LONG_TEXT,
+    _enums_field_type_enum_js__rspack_import_2/* .FieldType.EMAIL */.P.EMAIL
+]);
+/** The field's rules a Request body checks the same way the record write does. */ function inputRules(field) {
+    const rules = field.validationRules ?? {};
+    const keys = NUMERIC_TYPES.has(field.fieldType) ? [
+        'min',
+        'max'
+    ] : TEXT_TYPES.has(field.fieldType) ? [
+        'minLength',
+        'maxLength'
+    ] : [];
+    return Object.fromEntries(keys.filter((key)=>typeof rules[key] === 'number' && Number.isFinite(rules[key])).map((key)=>[
+            key,
+            rules[key]
+        ]));
+}
+/**
+ * The Request body input of a field: a choice carries its options, a multi-select is a list of
+ * those choices, a relation or file is an id. `rules`: a write also checks the field's own value rules.
+ */ function fieldInput(field, required, rules = true) {
     const options = optionValues(field.selectOptions);
-    const type = INPUT_TYPE[field.fieldType] === 'choice' && !options.length ? 'string' : INPUT_TYPE[field.fieldType];
-    return {
+    const base = {
         name: field.code,
         label: field.label || field.code,
-        type,
         ...required ? {
             required: true
         } : {},
+        ...rules ? inputRules(field) : {}
+    };
+    if (field.fieldType === _enums_field_type_enum_js__rspack_import_2/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT) return {
+        ...base,
+        type: 'array',
+        ...options.length ? {
+            itemType: 'choice',
+            options
+        } : {
+            itemType: 'string'
+        }
+    };
+    const type = INPUT_TYPE[field.fieldType] === 'choice' && !options.length ? 'string' : INPUT_TYPE[field.fieldType];
+    return {
+        ...base,
+        type,
         ...type === 'choice' ? {
             options
         } : {}
@@ -248,7 +2036,8 @@ const fieldMap = (fields, scope)=>Object.fromEntries(fields.map((f)=>[
             ref(`${scope}.${f.code}`)
         ]));
 const optionalFieldInputs = (fields)=>fields.map((f)=>fieldInput(f, false));
-/** Fields an equality filter can match - a list or JSON value cannot be compared as one value. */ const filterableFields = (entity)=>entity.fields.filter((f)=>f.fieldType !== _enums_field_type_enum_js__rspack_import_1/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT && f.fieldType !== _enums_field_type_enum_js__rspack_import_1/* .FieldType.JSON */.P.JSON);
+/** Inputs of a read filter: only the value's type is checked, never the write rules. */ const filterInputs = (fields)=>fields.map((f)=>fieldInput(f, false, false));
+/** Fields an equality filter can match - a list or JSON value cannot be compared as one value. */ const filterableFields = (entity)=>entity.fields.filter((f)=>f.fieldType !== _enums_field_type_enum_js__rspack_import_2/* .FieldType.MULTI_SELECT */.P.MULTI_SELECT && f.fieldType !== _enums_field_type_enum_js__rspack_import_2/* .FieldType.JSON */.P.JSON);
 const idInput = (t)=>({
         name: 'id',
         label: t.inputLabels.id,
@@ -275,56 +2064,53 @@ const respond = (id, column, statusCode, body, row)=>({
             body
         }
     });
-/** The body is the list itself (`itemSchema` checks each item): foreach `input` -> `body` (per item) ... done -> respond with the collected results. */ function bulkGraph(itemSchema, body, bodyEdges, collect, statusCode) {
-    return {
-        bodyType: 'list',
-        inputSchema: itemSchema,
-        steps: [
-            {
-                id: 'each',
-                type: 'foreach',
-                column: 1,
-                config: {
-                    items: ref('input'),
-                    maxItems: BULK_MAX_ITEMS,
-                    collect
-                }
-            },
-            ...body,
-            respond('respond', 2, statusCode, ref('context.each.results'))
-        ],
-        edges: [
-            [
-                'each',
-                'each',
-                body[0].id
-            ],
-            ...bodyEdges,
-            [
-                'each',
-                'done',
-                'respond'
-            ]
-        ],
-        isTransactional: true
-    };
-}
-function endpointGraph(entity, endpoint, texts) {
+/**
+ * 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.
+ */ function endpointGraph(entity, endpoint, texts) {
+    const id = (step)=>`${endpoint}_${step}`;
     const entityCode = entity.code;
     const single = (inputSchema, step, statusCode = 200)=>({
             inputSchema,
             steps: [
                 {
                     ...step,
+                    id: id('record'),
                     column: 1
                 },
-                respond('respond', 2, statusCode, ref(`context.${step.id}`))
+                respond(id('respond'), 2, statusCode, ref(`context.${id('record')}`))
+            ],
+            edges: [
+                [
+                    id('record'),
+                    'out',
+                    id('respond')
+                ]
+            ]
+        });
+    const bulk = (itemSchema, step, statusCode)=>({
+            bodyType: 'list',
+            inputSchema: itemSchema,
+            steps: [
+                {
+                    ...step,
+                    id: id('records'),
+                    column: 1,
+                    config: {
+                        ...step.config,
+                        target: 'many',
+                        items: ref('input')
+                    }
+                },
+                respond(id('respond'), 2, statusCode, ref(`context.${id('records')}.items`))
             ],
             edges: [
                 [
-                    step.id,
+                    id('records'),
                     'out',
-                    'respond'
+                    id('respond')
                 ]
             ]
         });
@@ -333,7 +2119,6 @@ function endpointGraph(entity, endpoint, texts) {
     switch(endpoint){
         case 'insert':
             return single(insertInputs, {
-                id: 'record',
                 type: 'entity_insert',
                 config: {
                     entityCode,
@@ -341,23 +2126,17 @@ function endpointGraph(entity, endpoint, texts) {
                 }
             }, 201);
         case 'insertMany':
-            return bulkGraph(insertInputs, [
-                {
-                    id: 'record',
-                    type: 'entity_insert',
-                    column: 1,
-                    row: 1,
-                    config: {
-                        entityCode,
-                        fields: fieldMap(entity.fields, 'loop.item')
-                    }
+            return bulk(insertInputs, {
+                type: 'entity_insert',
+                config: {
+                    entityCode,
+                    fields: fieldMap(entity.fields, 'loop.item')
                 }
-            ], [], ref('context.record'), 201);
+            }, 201);
         case 'getById':
             return single([
                 idInput(texts)
             ], {
-                id: 'record',
                 type: 'entity_get',
                 config: {
                     entityCode,
@@ -368,7 +2147,6 @@ function endpointGraph(entity, endpoint, texts) {
             return single([
                 idsInput(texts)
             ], {
-                id: 'records',
                 type: 'entity_query',
                 config: {
                     entityCode,
@@ -378,7 +2156,7 @@ function endpointGraph(entity, endpoint, texts) {
                             value: ref('input.ids')
                         }
                     },
-                    limit: _flow_engine_flow_types_js__rspack_import_0/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT
+                    limit: _flow_engine_flow_types_js__rspack_import_1/* .FLOW_LIMITS.MAX_QUERY_LIMIT */.Or.MAX_QUERY_LIMIT
                 }
             });
         case 'getAll':
@@ -388,9 +2166,8 @@ function endpointGraph(entity, endpoint, texts) {
                     label: texts.inputLabels.search,
                     type: 'string'
                 },
-                ...optionalFieldInputs(filterFields)
+                ...filterInputs(filterFields)
             ], {
-                id: 'records',
                 type: 'entity_query',
                 config: {
                     entityCode,
@@ -406,11 +2183,11 @@ function endpointGraph(entity, endpoint, texts) {
                         ...idInput(texts),
                         required: false
                     },
-                    ...optionalFieldInputs(filterFields)
+                    ...filterInputs(filterFields)
                 ],
                 steps: [
                     {
-                        id: 'records',
+                        id: id('records'),
                         type: 'entity_query',
                         column: 1,
                         config: {
@@ -423,7 +2200,7 @@ function endpointGraph(entity, endpoint, texts) {
                         }
                     },
                     {
-                        id: 'found',
+                        id: id('found'),
                         type: 'condition',
                         column: 2,
                         config: {
@@ -431,35 +2208,35 @@ function endpointGraph(entity, endpoint, texts) {
                                 operator: 'AND',
                                 conditions: [
                                     {
-                                        field: 'context.records.items',
+                                        field: `context.${id('records')}.items`,
                                         comparison: 'is_not_empty'
                                     }
                                 ]
                             }
                         }
                     },
-                    respond('respond', 3, 200, ref('context.records.items.0')),
-                    respond('not_found', 3, 404, {
+                    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_2/* .GENERIC_RECORD_MESSAGES.NO_MATCH */.j4.NO_MATCH)
+                        messageKey: lit(_config_message_keys_js__rspack_import_4/* .GENERIC_RECORD_MESSAGES.NO_MATCH */.j4.NO_MATCH)
                     }, 1)
                 ],
                 edges: [
                     [
-                        'records',
+                        id('records'),
                         'out',
-                        'found'
+                        id('found')
                     ],
                     [
-                        'found',
+                        id('found'),
                         'true',
-                        'respond'
+                        id('respond')
                     ],
                     [
-                        'found',
+                        id('found'),
                         'false',
-                        'not_found'
+                        id('not_found')
                     ]
                 ]
             };
@@ -468,7 +2245,6 @@ function endpointGraph(entity, endpoint, texts) {
                 idInput(texts),
                 ...optionalFieldInputs(entity.fields)
             ], {
-                id: 'record',
                 type: 'entity_update',
                 config: {
                     entityCode,
@@ -477,117 +2253,35 @@ function endpointGraph(entity, endpoint, texts) {
                 }
             });
         case 'updateMany':
-            return bulkGraph([
+            return bulk([
                 idInput(texts),
                 ...optionalFieldInputs(entity.fields)
-            ], [
-                {
-                    id: 'record',
-                    type: 'entity_update',
-                    column: 1,
-                    row: 1,
-                    config: {
-                        entityCode,
-                        id: ref('loop.item.id'),
-                        fields: fieldMap(entity.fields, 'loop.item')
-                    }
+            ], {
+                type: 'entity_update',
+                config: {
+                    entityCode,
+                    fields: fieldMap(entity.fields, 'loop.item')
                 }
-            ], [], ref('context.record'), 200);
+            }, 200);
         case 'bulkUpsert':
-            return bulkGraph([
+            return bulk([
                 {
                     ...idInput(texts),
                     required: false
                 },
                 ...optionalFieldInputs(entity.fields)
-            ], [
-                {
-                    id: 'has_id',
-                    type: 'condition',
-                    column: 1,
-                    row: 1,
-                    config: {
-                        rule: {
-                            operator: 'AND',
-                            conditions: [
-                                {
-                                    field: 'loop.item.id',
-                                    comparison: 'is_not_empty'
-                                }
-                            ]
-                        }
-                    }
-                },
-                {
-                    id: 'updated',
-                    type: 'entity_update',
-                    column: 2,
-                    row: 1,
-                    config: {
-                        entityCode,
-                        id: ref('loop.item.id'),
-                        fields: fieldMap(entity.fields, 'loop.item')
-                    }
-                },
-                {
-                    id: 'inserted',
-                    type: 'entity_insert',
-                    column: 2,
-                    row: 2,
-                    config: {
-                        entityCode,
-                        fields: fieldMap(entity.fields, 'loop.item')
-                    }
-                },
-                {
-                    id: 'keep_updated',
-                    type: 'set',
-                    column: 3,
-                    row: 1,
-                    config: {
-                        values: {
-                            saved: ref('context.updated')
-                        }
-                    }
-                },
-                {
-                    id: 'keep_inserted',
-                    type: 'set',
-                    column: 3,
-                    row: 2,
-                    config: {
-                        values: {
-                            saved: ref('context.inserted')
-                        }
-                    }
+            ], {
+                type: 'entity_update',
+                config: {
+                    entityCode,
+                    fields: fieldMap(entity.fields, 'loop.item'),
+                    onNotFound: 'insert'
                 }
-            ], [
-                [
-                    'has_id',
-                    'true',
-                    'updated'
-                ],
-                [
-                    'has_id',
-                    'false',
-                    'inserted'
-                ],
-                [
-                    'updated',
-                    'out',
-                    'keep_updated'
-                ],
-                [
-                    'inserted',
-                    'out',
-                    'keep_inserted'
-                ]
-            ], ref('vars.saved'), 200);
+            }, 200);
         case 'delete':
             return single([
                 idInput(texts)
             ], {
-                id: 'record',
                 type: 'entity_delete',
                 config: {
                     entityCode,
@@ -597,11 +2291,15 @@ function endpointGraph(entity, endpoint, texts) {
     }
 }
 /**
- * A ready-made flow for one record endpoint of the generic API controller. It runs as the
- * caller, so the entity permissions still decide who may use it, and it is an ordinary flow
- * afterwards - the user can change or delete it like any other. The bulk endpoints take the list
- * of records as the body and loop over it in one transaction, so a failing item rolls back the whole request.
- */ function buildEntityFlow(entity, endpoint, texts = {}) {
+ * The ready-made flow of an entity: `api-flows/<entity>` with one Request step per endpoint of the
+ * generic API controller, each on its own path (`ENTITY_FLOW_PATHS`) with its own body, laid out
+ * one below the other. Each asks its caller for the entity's own permission (`entity_builder.entity.<code>.<action>`,
+ * created with the entity), since a flow's access is its only gate, and it is an ordinary flow
+ * afterwards - the user can change or delete it like any other. A
+ * write endpoint is transactional: a bulk endpoint writes its whole list in one step, so a failing
+ * item rolls back the whole request; a read endpoint opens none. A bulk body holds at most
+ * FLOW_LIMITS.MAX_WRITE_ITEMS items.
+ */ function buildEntityFlow(entity, endpoints, texts = {}) {
     const resolved = {
         inputLabels: {
             id: textOr(texts.inputLabels?.id, DEFAULT_INPUT_LABEL.id),
@@ -610,57 +2308,65 @@ function endpointGraph(entity, endpoint, texts) {
         },
         noMatchMessage: textOr(texts.noMatchMessage, DEFAULT_NO_MATCH_MESSAGE)
     };
-    const graph = endpointGraph(entity, endpoint, resolved);
-    const nodes = [
-        {
-            id: 'trigger',
+    const nodes = [];
+    const edges = [];
+    let band = 0;
+    for (const endpoint of endpoints){
+        const graph = endpointGraph(entity, endpoint, resolved);
+        const at = (column, row = 0)=>({
+                x: COLUMN.x + column * COLUMN.gap,
+                y: ROW.y + (band + row) * ROW.gap
+            });
+        const config = {
+            path: ENTITY_FLOW_PATHS[endpoint],
+            bodyType: graph.bodyType ?? 'object',
+            inputSchema: graph.inputSchema,
+            authMode: 'permission',
+            permissions: endpointPermissions(entity.code, endpoint),
+            ...READ_ENDPOINTS.has(endpoint) ? {} : {
+                isTransactional: true
+            }
+        };
+        nodes.push({
+            id: endpoint,
             type: 'trigger',
-            name: '',
-            position: {
-                x: COLUMN.x,
-                y: ROW.y
-            },
-            config: {}
-        },
-        ...graph.steps.map(({ column, row, ...step })=>({
+            name: textOr(texts.names?.[endpoint], DEFAULT_ENDPOINT_NAME[endpoint]).slice(0, MAX_NAME_LENGTH),
+            position: at(0),
+            config
+        }, ...graph.steps.map(({ column, row, ...step })=>({
                 ...step,
                 name: '',
-                position: {
-                    x: COLUMN.x + column * COLUMN.gap,
-                    y: ROW.y + (row ?? 0) * ROW.gap
-                }
-            }))
-    ];
-    const edges = [
-        [
-            'trigger',
-            'out',
-            graph.steps[0].id
-        ],
-        ...graph.edges
-    ].map(([from, port, to])=>({
-            id: `e_${from}_${port}_${to}`,
-            from,
-            port,
-            to
-        }));
+                position: at(column, row)
+            })));
+        edges.push(...[
+            [
+                endpoint,
+                'out',
+                graph.steps[0].id
+            ],
+            ...graph.edges
+        ].map(([from, port, to])=>({
+                id: `e_${from}_${port}_${to}`,
+                from,
+                port,
+                to
+            })));
+        band += 1 + Math.max(0, ...graph.steps.map((step)=>step.row ?? 0));
+    }
     return {
-        name: `${entity.label} - ${textOr(texts.names?.[endpoint], DEFAULT_FLOW_NAME[endpoint])}`.slice(0, MAX_FLOW_NAME_LENGTH),
-        slug: entityFlowSlug(entity.code, endpoint),
+        name: entity.label.slice(0, MAX_NAME_LENGTH),
+        slug: entityFlowSlug(entity.code),
         isActive: true,
-        authMode: 'jwt',
-        runAs: 'caller',
-        isTransactional: graph.isTransactional ?? false,
-        bodyType: graph.bodyType ?? 'object',
-        inputSchema: graph.inputSchema,
         nodes,
         edges
     };
 }
 
 __webpack_require__.d(__webpack_exports__, {
-  C: () => (buildEntityFlow),
-  x: () => (entityFlowSlug)
+  CO: () => (buildEntityFlow)
+}, {
+  IP: ENTITY_FLOW_PATHS,
+  x2: entityFlowSlug
 });
 
 
@@ -1854,8 +3560,8 @@ class SchemaEvolutionService {
         const prepared = await this.prepare(request, user);
         return this.executor.simulate(prepared.target, prepared.run, prepared.impact);
     }
-    async apply(request, user) {
-        const prepared = await this.prepare(request, user);
+    /** `options.fieldId`: the id add_field gives the new field (an import keeps the id it has where it was designed). */ async apply(request, user, options = {}) {
+        const prepared = await this.prepare(request, user, options.fieldId);
         const { plan, outcome } = await this.executor.apply(prepared.target, prepared.run, {
             confirm: request.confirm === true,
             impact: prepared.impact
@@ -2033,10 +3739,10 @@ class SchemaEvolutionService {
         return true;
     }
     // ── dispatch ────────────────────────────────────────────────────────────────────────
-    async prepare(request, user) {
+    async prepare(request, user, fieldId) {
         switch(request.action){
             case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.ADD_FIELD */.M3.ADD_FIELD:
-                return this.prepareAddField(request, user);
+                return this.prepareAddField(request, user, fieldId);
             case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.UPDATE_FIELD */.M3.UPDATE_FIELD:
                 return this.prepareUpdateField(request, user);
             case _dtos_schema_change_dto_js__rspack_import_6/* .SchemaChangeAction.DEPRECATE_FIELD */.M3.DEPRECATE_FIELD:
@@ -2133,7 +3839,7 @@ class SchemaEvolutionService {
         return table.indices.filter((i)=>i.columnNames.length === 1 && i.columnNames[0] === column && i.isUnique === unique);
     }
     // ── add_field ───────────────────────────────────────────────────────────────────────
-    async prepareAddField(request, user) {
+    async prepareAddField(request, user, fieldId) {
         const { definition: loaded } = await this.loadEntity(request.entityDefinitionId);
         const spec = request.field;
         if (!spec) {
@@ -2158,7 +3864,12 @@ class SchemaEvolutionService {
             const nullable = spec.nullable ?? true;
             const unique = spec.unique ?? false;
             const dbType = this.adapter.mapFieldType(spec.fieldType, ctx.driver);
-            if (spec.relationTargetEntityId) {
+            const isRelation = spec.fieldType === _enums_field_type_enum_js__rspack_import_20/* .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, {
+                    field: spec.code
+                }));
+            } else if (isRelation) {
                 const target = await ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_7/* .EntityDefinition */.f).findOne({
                     where: {
                         id: spec.relationTargetEntityId
@@ -2198,8 +3909,8 @@ class SchemaEvolutionService {
                     }));
                 }
             }
-            // Every existing row gets the same backfill value, so two rows or more would clash.
-            if (unique && backfill !== null && rows > 1) {
+            // 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));
             }
             if (ctx.blocked || !table) {
@@ -2249,10 +3960,13 @@ class SchemaEvolutionService {
                     await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_17/* .plainIndex */.v7)(definition.tableName, spec.code, ctx.driver, this.adapter));
                 });
             }
-            let fieldId = null;
+            let savedFieldId = null;
             await ctx.metadata(async ()=>{
                 const repo = ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_8/* .FieldDefinition */.c);
                 const saved = await repo.save(repo.create({
+                    ...fieldId ? {
+                        id: fieldId
+                    } : {},
                     entityDefinitionId: definition.id,
                     code: spec.code,
                     label: spec.label,
@@ -2264,18 +3978,18 @@ class SchemaEvolutionService {
                     defaultValue: spec.defaultValue ?? null,
                     validationRules: spec.validationRules ?? null,
                     selectOptions: spec.selectOptions ?? null,
-                    relationTargetEntityId: spec.relationTargetEntityId ?? null,
+                    relationTargetEntityId: isRelation ? spec.relationTargetEntityId : null,
                     order: spec.order ?? Math.max(-1, ...fields.map((f)=>f.order)) + 1,
                     uiConfig: spec.uiConfig ?? null,
                     isSearchable: spec.isSearchable ?? false,
                     isSystemField: false,
                     deprecatedAt: null
                 }));
-                fieldId = saved.id;
+                savedFieldId = saved.id;
             });
             return {
                 operation: _enums_ddl_operation_enum_js__rspack_import_21/* .DdlOperation.ADD_COLUMN */.i.ADD_COLUMN,
-                fieldDefinitionId: fieldId,
+                fieldDefinitionId: savedFieldId,
                 diff: {
                     field: {
                         code: spec.code,
@@ -3280,21 +4994,23 @@ __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_16 = __webpack_require__(5732);
+/* import */ var _config_message_keys_js__rspack_import_17 = __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_18 = __webpack_require__(9949);
-/* import */ var _enums_entity_status_enum_js__rspack_import_19 = __webpack_require__(1313);
+/* 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 _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);
 /* import */ var _entity_permission_service_js__rspack_import_10 = __webpack_require__(1462);
-/* import */ var _flow_definition_service_js__rspack_import_11 = __webpack_require__(5229);
-/* import */ var _identifier_rules_js__rspack_import_12 = __webpack_require__(413);
-/* import */ var _schema_change_executor_service_js__rspack_import_13 = __webpack_require__(6605);
-/* import */ var _schema_columns_js__rspack_import_14 = __webpack_require__(5313);
-/* import */ var _schema_dialect_adapter_service_js__rspack_import_15 = __webpack_require__(7259);
+/* import */ var _field_value_validator_js__rspack_import_11 = __webpack_require__(3525);
+/* import */ var _flow_definition_service_js__rspack_import_12 = __webpack_require__(5229);
+/* 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);
 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") {
@@ -3338,6 +5054,11 @@ function _ts_param(paramIndex, decorator) {
 
 
 
+
+
+const presetId = (id)=>id ? {
+        id
+    } : {};
 class SchemaSyncService {
     dataSourceProvider;
     dialectAdapter;
@@ -3353,17 +5074,17 @@ class SchemaSyncService {
         this.flowDefinitionService = flowDefinitionService;
     }
     validateCreateRequest(dto) {
-        (0,_identifier_rules_js__rspack_import_12/* .assertValidIdentifier */.kV)(dto.code, 'entity');
+        (0,_identifier_rules_js__rspack_import_13/* .assertValidIdentifier */.kV)(dto.code, 'entity');
         const fields = dto.fields ?? [];
         for (const field of fields){
-            (0,_identifier_rules_js__rspack_import_12/* .assertValidIdentifier */.kV)(field.code, 'field');
-            (0,_identifier_rules_js__rspack_import_12/* .assertIndexableField */.fY)(field);
+            (0,_identifier_rules_js__rspack_import_13/* .assertValidIdentifier */.kV)(field.code, 'field');
+            (0,_identifier_rules_js__rspack_import_13/* .assertIndexableField */.fY)(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_16/* .SCHEMA_MESSAGES.DUPLICATE_FIELD_CODE */.Hu.DUPLICATE_FIELD_CODE,
+                messageKey: _config_message_keys_js__rspack_import_17/* .SCHEMA_MESSAGES.DUPLICATE_FIELD_CODE */.Hu.DUPLICATE_FIELD_CODE,
                 messageVariables: {
                     code: duplicate
                 }
@@ -3371,7 +5092,7 @@ class SchemaSyncService {
         }
     }
     async createTarget(dto, user) {
-        const lockCodes = await (0,_schema_change_executor_service_js__rspack_import_13/* .relationTargetCodes */.e)(this.dataSourceProvider, (dto.fields ?? []).map((f)=>f.relationTargetEntityId));
+        const lockCodes = await (0,_schema_change_executor_service_js__rspack_import_14/* .relationTargetCodes */.e)(this.dataSourceProvider, (dto.fields ?? []).map((f)=>f.relationTargetEntityId));
         return {
             action: 'create_entity',
             entityDefinitionId: null,
@@ -3381,7 +5102,7 @@ class SchemaSyncService {
             lockCodes
         };
     }
-    createRun(dto, user, created) {
+    createRun(dto, user, created, ids = {}) {
         const tableName = `${(/* inlined export .ENTITY_TABLE_PREFIX */"eb_")}${dto.code}`;
         const fieldSpecs = dto.fields ?? [];
         const flowEndpoints = dto.flowEndpoints ?? [];
@@ -3392,7 +5113,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_16/* .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_17/* .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);
@@ -3401,41 +5122,61 @@ class SchemaSyncService {
                     code: dto.code
                 }
             });
-            if (known) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .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_17/* .SCHEMA_BLOCKER_MESSAGES.ENTITY_CODE_EXISTS */.M3.ENTITY_CODE_EXISTS, {
                 code: dto.code
             }));
-            for (const spec of fieldSpecs){
-                if (spec.relationTargetEntityId) {
-                    const target = await definitions.findOne({
-                        where: {
-                            id: spec.relationTargetEntityId
-                        }
-                    });
-                    if (!target) ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .SCHEMA_BLOCKER_MESSAGES.RELATION_FIELD_TARGET_MISSING */.M3.RELATION_FIELD_TARGET_MISSING, {
+            for (const spec of fieldSpecs.filter((f)=>f.fieldType === _enums_field_type_enum_js__rspack_import_19/* .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, {
                         field: spec.code
                     }));
+                    continue;
                 }
+                const target = await definitions.findOne({
+                    where: {
+                        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, {
+                    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)=>[
+                    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, {
+                problem: (0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(error.messageKey, error.messageVariables)
+            }));
             if (flowEndpoints.length) {
-                const slugs = flowEndpoints.map((endpoint)=>(0,_entity_flow_scaffold_js__rspack_import_9/* .entityFlowSlug */.x)(dto.code, endpoint));
-                const clashes = await ctx.qr.manager.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G).find({
+                const slug = (0,_entity_flow_scaffold_js__rspack_import_9/* .entityFlowSlug */.x2)(dto.code);
+                const clash = await ctx.qr.manager.getRepository(_entities_flow_definition_entity_js__rspack_import_6/* .FlowDefinition */.G).findOne({
                     select: {
                         slug: true
                     },
                     where: {
-                        slug: (0,typeorm__rspack_import_3.In)(slugs)
+                        slug
                     },
                     withDeleted: true
                 });
-                for (const clash of clashes)ctx.block((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .SCHEMA_BLOCKER_MESSAGES.FLOW_SLUG_TAKEN */.M3.FLOW_SLUG_TAKEN, {
-                    slug: clash.slug
+                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, {
+                    slug
                 }));
             }
             if (ctx.blocked) return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_18/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
+                operation: _enums_ddl_operation_enum_js__rspack_import_20/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
                 diff: {}
             };
-            const columns = fieldSpecs.map((spec)=>(0,_schema_columns_js__rspack_import_14/* .buildFieldColumn */.fu)({
+            const columns = fieldSpecs.map((spec)=>(0,_schema_columns_js__rspack_import_15/* .buildFieldColumn */.fu)({
                     code: spec.code,
                     fieldType: spec.fieldType,
                     dbType: '',
@@ -3448,33 +5189,34 @@ class SchemaSyncService {
             const table = new typeorm__rspack_import_3.Table({
                 name: tableName,
                 columns: [
-                    ...(0,_schema_columns_js__rspack_import_14/* .buildSystemColumns */.Rm)({
+                    ...(0,_schema_columns_js__rspack_import_15/* .buildSystemColumns */.Rm)({
                         isSoftDeleteEnabled,
                         isAuditEnabled
                     }, ctx.driver),
                     ...columns
                 ]
             });
-            await ctx.ddl((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .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_17/* .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_16/* .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_17/* .SCHEMA_STEP_MESSAGES.ADD_INDEX */.EQ.ADD_INDEX, {
                     column: spec.code
                 }), async ()=>{
-                    await ctx.qr.createIndex(table, (0,_schema_columns_js__rspack_import_14/* .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));
                 });
             }
             await ctx.metadata(async ()=>{
                 const definitionRepo = ctx.qr.manager.getRepository(_entities_entity_definition_entity_js__rspack_import_4/* .EntityDefinition */.f);
                 const definition = await definitionRepo.save(definitionRepo.create({
+                    ...presetId(ids.entityId),
                     code: dto.code,
                     label: dto.label,
                     description: dto.description ?? null,
                     tableName,
-                    status: _enums_entity_status_enum_js__rspack_import_19/* .EntityStatus.ACTIVE */.c.ACTIVE,
+                    status: _enums_entity_status_enum_js__rspack_import_21/* .EntityStatus.ACTIVE */.c.ACTIVE,
                     schemaVersion: 1,
                     isSoftDeleteEnabled,
                     isAuditEnabled,
@@ -3483,6 +5225,7 @@ class SchemaSyncService {
                 const fieldRepo = ctx.qr.manager.getRepository(_entities_field_definition_entity_js__rspack_import_5/* .FieldDefinition */.c);
                 if (fieldSpecs.length) {
                     await fieldRepo.save(fieldSpecs.map((spec, index)=>fieldRepo.create({
+                            ...presetId(ids.fieldIds?.[spec.code]),
                             entityDefinitionId: definition.id,
                             code: spec.code,
                             label: spec.label,
@@ -3494,7 +5237,7 @@ class SchemaSyncService {
                             defaultValue: spec.defaultValue ?? null,
                             validationRules: spec.validationRules ?? null,
                             selectOptions: spec.selectOptions ?? null,
-                            relationTargetEntityId: spec.relationTargetEntityId ?? null,
+                            relationTargetEntityId: spec.fieldType === _enums_field_type_enum_js__rspack_import_19/* .FieldType.RELATION */.P.RELATION ? spec.relationTargetEntityId : null,
                             order: spec.order ?? index,
                             uiConfig: spec.uiConfig ?? null,
                             isSearchable: spec.isSearchable ?? false,
@@ -3505,7 +5248,7 @@ class SchemaSyncService {
                 created.definition = definition;
             });
             return {
-                operation: _enums_ddl_operation_enum_js__rspack_import_18/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
+                operation: _enums_ddl_operation_enum_js__rspack_import_20/* .DdlOperation.CREATE_TABLE */.i.CREATE_TABLE,
                 entityDefinitionId: created.definition?.id ?? null,
                 diff: {
                     fields: fieldSpecs.map((f)=>({
@@ -3519,36 +5262,34 @@ class SchemaSyncService {
                     try {
                         await this.entityPermissionService.provisionForEntity(created.definition);
                     } finally{
-                        created.warnings.push(...await this.createEndpointFlows(dto, flowEndpoints, user));
+                        if (flowEndpoints.length) created.warnings.push(...await this.createEndpointFlow(dto, flowEndpoints, user));
                     }
                 }
             };
         };
     }
     /**
-   * One ready-made flow per requested endpoint, saved through FlowDefinitionService so it is
-   * validated like any other flow. Each is saved on its own: one that fails does not stop the
-   * rest, and is reported as a warning since the entity is already committed.
-   */ async createEndpointFlows(dto, endpoints, user) {
-        const entity = {
+   * The entity's ready-made flow, one Request step per requested endpoint, saved through
+   * FlowDefinitionService so it is validated like any other flow. The entity is already committed,
+   * so a flow that cannot be saved is reported as a warning.
+   */ async createEndpointFlow(dto, endpoints, user) {
+        const flow = (0,_entity_flow_scaffold_js__rspack_import_9/* .buildEntityFlow */.CO)({
             code: dto.code,
             label: dto.label,
             fields: dto.fields ?? []
-        };
-        const warnings = [];
-        for (const endpoint of endpoints){
-            const flow = (0,_entity_flow_scaffold_js__rspack_import_9/* .buildEntityFlow */.C)(entity, endpoint, dto.flowTexts);
-            try {
-                await this.flowDefinitionService.insert(flow, user);
-            } catch (error) {
-                this.logger.error(`Endpoint flow '${flow.slug}' of entity '${dto.code}' could not be created: ${error.message}`);
-                warnings.push((0,_flusys_nestjs_shared_utils__rspack_import_1.messageRef)(_config_message_keys_js__rspack_import_16/* .SCHEMA_WARNING_MESSAGES.ENDPOINT_FLOW_FAILED */.Uu.ENDPOINT_FLOW_FAILED, {
+        }, endpoints, dto.flowTexts);
+        try {
+            await this.flowDefinitionService.insert(flow, user);
+            return [];
+        } 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, {
                     slug: flow.slug,
                     detail: (0,_flow_engine_flow_errors_js__rspack_import_7/* .errorRef */.O$)(error)
-                }));
-            }
+                })
+            ];
         }
-        return warnings;
     }
     /** Preview of `createEntity`: the CREATE TABLE / CREATE INDEX statements, nothing is created. */ async planCreateEntity(dto, user) {
         this.validateCreateRequest(dto);
@@ -3556,7 +5297,7 @@ class SchemaSyncService {
             warnings: []
         }));
     }
-    async createEntity(dto, user) {
+    async createEntity(dto, user, ids = {}) {
         this.validateCreateRequest(dto);
         if (dto.flowEndpoints?.length) await this.flowDefinitionService.assertMayCreate(user);
         const created = {
@@ -3564,12 +5305,12 @@ class SchemaSyncService {
         };
         let planWarnings;
         try {
-            ({ plan: { warnings: planWarnings } } = await this.executor.apply(await this.createTarget(dto, user), this.createRun(dto, user, created)));
+            ({ 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_16/* .SCHEMA_BLOCKER_MESSAGES.ENTITY_CODE_EXISTS */.M3.ENTITY_CODE_EXISTS || b.messageKey === _config_message_keys_js__rspack_import_16/* .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_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)) {
                 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_16/* .ENTITY_DEFINITION_MESSAGES.CODE_ALREADY_EXISTS */.pL.CODE_ALREADY_EXISTS,
+                    messageKey: _config_message_keys_js__rspack_import_17/* .ENTITY_DEFINITION_MESSAGES.CODE_ALREADY_EXISTS */.pL.CODE_ALREADY_EXISTS,
                     messageVariables: {
                         code: dto.code
                     }
@@ -3591,17 +5332,17 @@ 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_15/* .SchemaDialectAdapterService */.I)),
-    _ts_param(2, (0,_nestjs_common__rspack_import_2.Inject)(_schema_change_executor_service_js__rspack_import_13/* .SchemaChangeExecutor */.T)),
+    _ts_param(1, (0,_nestjs_common__rspack_import_2.Inject)(_schema_dialect_adapter_service_js__rspack_import_16/* .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_11/* .FlowDefinitionService */.Tk)),
+    _ts_param(4, (0,_nestjs_common__rspack_import_2.Inject)(_flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk)),
     _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_15/* .SchemaDialectAdapterService */.I === "undefined" ? Object : _schema_dialect_adapter_service_js__rspack_import_15/* .SchemaDialectAdapterService */.I,
-        typeof _schema_change_executor_service_js__rspack_import_13/* .SchemaChangeExecutor */.T === "undefined" ? Object : _schema_change_executor_service_js__rspack_import_13/* .SchemaChangeExecutor */.T,
+        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_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_11/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_11/* .FlowDefinitionService */.Tk
+        typeof _flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk === "undefined" ? Object : _flow_definition_service_js__rspack_import_12/* .FlowDefinitionService */.Tk
     ])
 ], SchemaSyncService);