@qingflow-tech/qingflow-cli 1.1.43-beta.1 → 1.1.43-beta.3

package/src/qingflow_mcp/builder_facade/app_form.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import base64
 from copy import deepcopy
 from dataclasses import dataclass
 import json
 import re
 from typing import Any, Iterable
+from urllib.parse import unquote_plus
 
 from ..app_form_compat import normalize_app_form_declaration, validate_app_form_create_icon
 from ..errors import QingflowApiError, is_auth_like_error
@@ -19,6 +21,8 @@ from .service import (
     _compile_code_block_binding_fields,
     _compile_q_linker_binding_fields,
     _field_to_question,
+    _looks_like_backend_encoded_formula,
+    _normalize_formula_defaults_for_save,
     _normalize_and_validate_code_block_fields_for_write,
 )
 
@@ -159,6 +163,17 @@ def _positive_int(value: Any) -> int | None:
     return result if result > 0 else None
 
 
+def _decode_formula_default(value: Any) -> Any:
+    if not isinstance(value, str) or not _looks_like_backend_encoded_formula(value):
+        return value
+    encoded = value[16:-16]
+    try:
+        decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
+        return unquote_plus(decoded)
+    except Exception:
+        return value
+
+
 def _without_none(value: Any) -> Any:
     if isinstance(value, dict):
         return {key: _without_none(item) for key, item in value.items() if item is not None}
@@ -167,6 +182,117 @@ def _without_none(value: Any) -> Any:
     return value
 
 
+def _canonical_unlimited(value: Any) -> Any:
+    """Expose the backend -1 sentinel as the declarative null/omitted form."""
+    return None if value == -1 else value
+
+
+def _backend_unlimited(value: Any) -> Any:
+    """Translate an explicit declarative null back to the backend -1 sentinel."""
+    return -1 if value is None else value
+
+
+def _scope_items(scope: Any, key: str) -> list[JSONObject]:
+    value = scope.get(key) if isinstance(scope, dict) else None
+    return [item for item in value if isinstance(item, dict)] if isinstance(value, list) else []
+
+
+def _backend_member_scope(scope: Any) -> JSONObject | None:
+    """Translate the public member/depart scope to AuthMembersIncludeExternalBean JSON."""
+    if not isinstance(scope, dict):
+        return None
+    result: JSONObject = {
+        "member": [{"uid": item.get("uid"), "nickName": item.get("nickName")} for item in _scope_items(scope, "members")],
+        "depart": [{"deptId": item.get("deptId"), "deptName": item.get("deptName")} for item in _scope_items(scope, "departments")],
+        "role": [{"roleId": item.get("roleId"), "roleName": item.get("roleName")} for item in _scope_items(scope, "roles")],
+        "dynamic": deepcopy(_scope_items(scope, "dynamic")),
+        "externalMemberList": deepcopy(_scope_items(scope, "externalMembers")),
+        "externalDepartList": deepcopy(_scope_items(scope, "externalDepartments")),
+    }
+    if "includeSubDeparts" in scope:
+        result["includeSubDeparts"] = bool(scope.get("includeSubDeparts"))
+    return result
+
+
+def _canonical_member_scope(scope: Any, scope_type: Any, *, department: bool = False) -> JSONObject:
+    normalized_type = _positive_int(scope_type) or 1
+    if normalized_type == 1:
+        return {"mode": "all"}
+    raw = scope if isinstance(scope, dict) else {}
+    result: JSONObject = {
+        "mode": "custom" if normalized_type == 2 else "relation",
+        "includeSubDeparts": bool(raw.get("includeSubDeparts")),
+    }
+    if department:
+        result["departments"] = [
+            _without_none({"deptId": _positive_int(item.get("deptId") or item.get("id")), "deptName": item.get("deptName") or item.get("name")})
+            for item in _scope_items(raw, "depart")
+            if _positive_int(item.get("deptId") or item.get("id")) is not None
+        ]
+    else:
+        result["members"] = [
+            _without_none({"uid": _positive_int(item.get("uid")), "nickName": item.get("nickName")})
+            for item in _scope_items(raw, "member")
+            if _positive_int(item.get("uid")) is not None
+        ]
+        result["departments"] = [
+            _without_none({"deptId": _positive_int(item.get("deptId")), "deptName": item.get("deptName")})
+            for item in _scope_items(raw, "depart")
+            if _positive_int(item.get("deptId")) is not None
+        ]
+        result["roles"] = [
+            _without_none({"roleId": _positive_int(item.get("roleId")), "roleName": item.get("roleName")})
+            for item in _scope_items(raw, "role")
+            if _positive_int(item.get("roleId")) is not None
+        ]
+        result["dynamic"] = [
+            _without_none({
+                "type": _positive_int(item.get("type")),
+                "queId": item.get("queId"),
+                "queTitle": item.get("queTitle"),
+            })
+            for item in _scope_items(raw, "dynamic")
+            if _positive_int(item.get("type")) is not None
+        ]
+        result["externalMembers"] = [
+            _without_none({
+                "uid": _positive_int(item.get("uid")),
+                "nickName": item.get("nickName"),
+                "email": item.get("email"),
+            })
+            for item in _scope_items(raw, "externalMemberList")
+            if _positive_int(item.get("uid")) is not None
+        ]
+        result["externalDepartments"] = [
+            _without_none({
+                "deptId": _positive_int(item.get("deptId")),
+                "deptName": item.get("deptName"),
+            })
+            for item in _scope_items(raw, "externalDepartList")
+            if _positive_int(item.get("deptId")) is not None
+        ]
+    return _without_none(result)
+
+
+def _canonical_scope_relation(relation: Any) -> JSONObject | None:
+    if not isinstance(relation, dict):
+        return None
+    displayed = relation.get("displayedQueInfo") if isinstance(relation.get("displayedQueInfo"), dict) else {}
+    displayed_id = _positive_int(relation.get("displayedQueId") or displayed.get("queId"))
+    if displayed_id is None or not displayed.get("appKey"):
+        return None
+    result: JSONObject = {
+        "displayedField": _selector(displayed_id, displayed.get("queTitle")),
+        "targetAppKey": displayed.get("appKey"),
+        "targetAppTitle": displayed.get("appTitle"),
+        "displayedFieldType": displayed.get("queType"),
+        "matchRuleType": relation.get("matchRuleType"),
+        "matchRules": relation.get("matchRules"),
+        "matchRuleFormula": relation.get("matchRuleFormula"),
+    }
+    return _without_none(result)
+
+
 def _selector(que_id: Any, name: Any) -> JSONObject:
     result: JSONObject = {}
     normalized_id = _positive_int(que_id)
@@ -221,6 +347,7 @@ def _semantic(value: Any) -> Any:
             key: _semantic(item)
             for key, item in sorted(value.items())
             if key not in identity_keys
+            and not key.startswith("_")
             and not (key == "sort" and isinstance(item, dict) and item.get("enabled") is False)
         }
     if isinstance(value, list):
@@ -308,6 +435,7 @@ def _validate_payload_limits(value: Any) -> None:
 class AppFormNormalizer:
     def from_backend(self, *, context: AppFormSchemaContext, app_key: str, form: JSONObject) -> JSONObject:
         relations = [item for item in form.get("questionRelations") or [] if isinstance(item, dict)]
+        select_scope_relations = [item for item in form.get("selectScopeRelations") or [] if isinstance(item, dict)]
         field_names = self._field_index(form)
         title_id = _positive_int(form.get("dataTitleQueId"))
         cover_id = _positive_int(form.get("dataCoverQueId"))
@@ -321,7 +449,7 @@ class AppFormNormalizer:
                 if section_id is None:
                     raise AppFormFailure("UNSUPPORTED_LAYOUT", "existing section has no stable ID", "NORMALIZE")
                 rows = [
-                    {"fields": [self._field(question, relations, title_id, cover_id, field_names) for question in inner if isinstance(question, dict)]}
+                    {"fields": [self._field(question, relations, select_scope_relations, title_id, cover_id, field_names) for question in inner if isinstance(question, dict)]}
                     for inner in section.get("innerQuestions") or []
                     if isinstance(inner, list) and inner
                 ]
@@ -329,7 +457,7 @@ class AppFormNormalizer:
                     raise AppFormFailure("UNSUPPORTED_LAYOUT", "existing section is empty", "NORMALIZE")
                 body.append({"kind": "section", "sectionId": str(section_id), "title": str(section.get("queTitle") or ""), "rows": rows})
             else:
-                body.append({"kind": "row", "fields": [self._field(question, relations, title_id, cover_id, field_names) for question in row if isinstance(question, dict)]})
+                body.append({"kind": "row", "fields": [self._field(question, relations, select_scope_relations, title_id, cover_id, field_names) for question in row if isinstance(question, dict)]})
         resource = {
             "apiVersion": context.api_version,
             "appKey": app_key,
@@ -349,6 +477,7 @@ class AppFormNormalizer:
         self,
         question: JSONObject,
         relations: list[JSONObject],
+        select_scope_relations: list[JSONObject],
         title_id: int | None,
         cover_id: int | None,
         field_names: dict[int, str],
@@ -381,6 +510,23 @@ class AppFormNormalizer:
             "required": bool(question.get("required")),
             "description": question.get("queHint") or None,
         }
+        default_type = _positive_int(question.get("queDefaultType"))
+        if default_type is not None and (
+            question.get("queDefaultValue") is not None
+            or (default_type != 1 and field_type != "relation")
+        ):
+            field["defaultType"] = default_type
+        raw_default_value = question.get("queDefaultValue")
+        if isinstance(raw_default_value, (dict, list)) and field_type not in {"address", "attachment", "relation", "subtable"}:
+            raise AppFormFailure(
+                "UNSUPPORTED_FIELD_CONFIG",
+                "structured default value must be declared through the field-specific config",
+                "NORMALIZE",
+                details={"queId": que_id, "type": field_type},
+            )
+        if "queDefaultValue" in question and raw_default_value is not None and not isinstance(raw_default_value, (dict, list)):
+            default_value = question.get("queDefaultValue")
+            field["defaultValue"] = _decode_formula_default(default_value) if default_type == 3 else deepcopy(default_value)
         if que_id is not None:
             field["queId"] = que_id
         width = _positive_int(question.get("queWidth"))
@@ -390,28 +536,123 @@ class AppFormNormalizer:
             field["dataTitle"] = True
         if cover_id is not None and que_id == cover_id:
             field["dataCover"] = True
-        if field_type in CHOICE_TYPES:
+        if field_type in {"text", "long_text", "link", "phone", "email"}:
+            config = _without_none({
+                "minWordCount": _canonical_unlimited(question.get("minWordCount")),
+                "maxWordCount": _canonical_unlimited(question.get("maxWordCount")),
+                "noRepeat": question.get("noRepeat"),
+                "canScan": question.get("canScan"),
+                "scanType": question.get("scanType"),
+            })
+            if field_type == "phone":
+                config.update(_without_none({
+                    "msgValidateStatus": question.get("msgValidateStatus"),
+                    "fixedPhone": question.get("fixedPhone"),
+                }))
+            if config:
+                field["config"] = config
+        elif field_type in {"number", "amount"}:
+            config = _without_none({
+                "numberLimitStatus": question.get("numberLimitStatus"),
+                "minValue": question.get("minValue"),
+                "maxValue": question.get("maxValue"),
+                "decimalDigit": question.get("decimalDigit"),
+                "numberFormat": question.get("numberFormat"),
+                "currencyStatus": question.get("currencyStatus"),
+                "currencyType": question.get("currencyType"),
+                "canDecimal": question.get("canDecimal"),
+                "noRepeat": question.get("noRepeat"),
+                "canScan": question.get("canScan"),
+                "scanType": question.get("scanType"),
+            })
+            if config:
+                field["config"] = config
+        elif field_type in CHOICE_TYPES:
             options = [str(item.get("optValue")) for item in question.get("options") or [] if isinstance(item, dict) and item.get("optValue") is not None]
             if not options and field_type == "single_choice":
                 options = ["是", "否"]
-            field["config"] = {"options": options}
+            field["config"] = _without_none({
+                "options": options,
+                "minOpts": _canonical_unlimited(question.get("minOpts")),
+                "maxOpts": _canonical_unlimited(question.get("maxOpts")),
+                "optDirection": question.get("optDirection") if question.get("optDirection") not in {None, 0} else None,
+                "optSelectMode": question.get("optSelectMode"),
+                "beingShowColor": question.get("beingShowColor"),
+                "defaultOptions": [str(item.get("optValue")) for item in question.get("options") or [] if isinstance(item, dict) and item.get("beingDefault") is True],
+            })
+            if not field["config"].get("defaultOptions"):
+                field["config"].pop("defaultOptions", None)
+        elif field_type == "member":
+            field["config"] = {
+                "memberScope": _canonical_member_scope(question.get("memberSelectScope"), question.get("memberSelectScopeType")),
+            }
+            if question.get("memberDftValue") is not None:
+                field["config"]["defaultMembers"] = _canonical_member_scope(question.get("memberDftValue"), 2)
+            relation = next((item for item in select_scope_relations if _positive_int(item.get("queId")) == que_id), None)
+            scope_relation = _canonical_scope_relation(relation)
+            if scope_relation is not None:
+                field["config"]["memberScopeRelation"] = scope_relation
+            for key in ("noRepeat", "canScan", "scanType"):
+                if question.get(key) is not None:
+                    field["config"][key] = question[key]
         elif field_type == "department":
             scope = question.get("deptSelectScope") if isinstance(question.get("deptSelectScope"), dict) else {}
             departments = scope.get("depart") if isinstance(scope.get("depart"), list) else []
-            if departments:
+            canonical_departments = [
+                _without_none({"deptId": _positive_int(item.get("deptId") or item.get("id")), "deptName": item.get("deptName") or item.get("name")})
+                for item in departments
+                if isinstance(item, dict) and _positive_int(item.get("deptId") or item.get("id")) is not None
+            ]
+            scope_type = _positive_int(question.get("deptSelectScopeType")) or 1
+            if scope_type == 3:
+                field["config"] = {"departmentScope": {"mode": "relation", "includeSubDeparts": bool(scope.get("includeSubDeparts"))}}
+            elif scope_type == 2 or (question.get("deptSelectScopeType") is None and canonical_departments):
+                if not canonical_departments:
+                    raise AppFormFailure(
+                        "UNSUPPORTED_FIELD_CONFIG",
+                        "department custom scope has no departments",
+                        "NORMALIZE",
+                        details={"queId": que_id},
+                    )
                 field["config"] = {
                     "departmentScope": {
                         "mode": "custom",
-                        "departments": [
-                            _without_none({"deptId": _positive_int(item.get("deptId") or item.get("id")), "deptName": item.get("deptName") or item.get("name")})
-                            for item in departments
-                            if isinstance(item, dict) and _positive_int(item.get("deptId") or item.get("id")) is not None
-                        ],
+                        "departments": canonical_departments,
                         "includeSubDeparts": bool(scope.get("includeSubDeparts")),
                     }
                 }
             else:
                 field["config"] = {"departmentScope": {"mode": "all", "includeSubDeparts": bool(scope.get("includeSubDeparts"))}}
+            if question.get("deptDftValue") is not None:
+                field["config"]["defaultDepartments"] = _canonical_member_scope(question.get("deptDftValue"), 2, department=True)
+            relation = next((item for item in select_scope_relations if _positive_int(item.get("queId")) == que_id), None)
+            scope_relation = _canonical_scope_relation(relation)
+            if scope_relation is not None:
+                field["config"]["departmentScopeRelation"] = scope_relation
+            for key in ("noRepeat", "canScan", "scanType", "beingShowParentPath"):
+                if question.get(key) is not None:
+                    field["config"][key] = question[key]
+        elif field_type == "attachment":
+            field["config"] = _without_none({
+                "fileSize": question.get("fileSize"),
+                "fileType": question.get("fileType"),
+                "fileBeingCaptureOnly": question.get("fileBeingCaptureOnly"),
+                "imageCompress": question.get("imageCompress"),
+                "pluginStatus": question.get("pluginStatus"),
+                "maxFileLimitStatus": question.get("maxFileLimitStatus"),
+                "maxFileLimit": question.get("maxFileLimit"),
+                "canScan": question.get("canScan"),
+                "scanType": question.get("scanType"),
+                "defaultValues": question.get("queDefaultValues") if isinstance(question.get("queDefaultValues"), dict) and (question.get("queDefaultValues", {}).get("values") or question.get("queDefaultValues", {}).get("tableValues")) else None,
+            })
+        elif field_type == "address":
+            field["config"] = _without_none({
+                "addressPrecision": question.get("addressPrecision"),
+                "pickPosition": question.get("pickPosition"),
+                "canScan": question.get("canScan"),
+                "scanType": question.get("scanType"),
+                "defaultValues": question.get("queDefaultValues") if isinstance(question.get("queDefaultValues"), dict) and (question.get("queDefaultValues", {}).get("values") or question.get("queDefaultValues", {}).get("tableValues")) else None,
+            })
         elif field_type == "relation":
             reference = question.get("referenceConfig") if isinstance(question.get("referenceConfig"), dict) else {}
             refer_questions = [item for item in reference.get("referQuestions") or [] if isinstance(item, dict)]
@@ -437,6 +678,9 @@ class AppFormNormalizer:
                         )
                         for item in visible
                     ],
+                    "beingDefaultFormulaAutoFillEnabled": reference.get("beingDefaultFormulaAutoFillEnabled"),
+                    "defaultValueMatchRules": reference.get("defaultValueMatchRules"),
+                    "defaultValues": question.get("queDefaultValues") if isinstance(question.get("queDefaultValues"), dict) else None,
                 }
             )
         elif field_type == "q_linker":
@@ -447,7 +691,7 @@ class AppFormNormalizer:
             field["config"] = self._data_relation_config(question, relations)
         elif field_type == "subtable":
             field["subfields"] = [
-                self._field(item, relations, None, None, field_names)
+                self._field(item, relations, select_scope_relations, None, None, field_names)
                 for item in question.get("subQuestions") or []
                 if isinstance(item, dict)
             ]
@@ -455,6 +699,13 @@ class AppFormNormalizer:
                 subfield.pop("width", None)
                 subfield.pop("dataTitle", None)
                 subfield.pop("dataCover", None)
+            field["config"] = _without_none({
+                "tableRowsLimit": question.get("tableRowsLimit"),
+                "tableNoRepeatStatus": question.get("tableNoRepeatStatus"),
+                "tableNoRepeatQuestion": [_selector(item, field_names.get(_positive_int(item))) for item in question.get("tableNoRepeatQuestion") or [] if _positive_int(item) is not None],
+                "tableRowHeight": question.get("tableRowHeight"),
+                "defaultValues": question.get("queDefaultValues") if isinstance(question.get("queDefaultValues"), dict) and (question.get("queDefaultValues", {}).get("values") or question.get("queDefaultValues", {}).get("tableValues")) else None,
+            })
         return field
 
     @staticmethod
@@ -958,9 +1209,7 @@ class AppFormCompiler:
         fields = list(_iter_fields(body))
         templates = self._question_templates(current_form or {})
         internal_fields = [self._internal_field(field, templates=templates) for field in fields]
-        for index, internal in enumerate(internal_fields):
-            if _positive_int(internal.get("que_id")) is None:
-                internal["que_temp_id"] = -10000 - (index * 100)
+        self._assign_layout_temp_ids(body, internal_fields)
         try:
             internal_fields, _ = _normalize_and_validate_code_block_fields_for_write(fields=internal_fields)
             internal_fields, relations = _compile_code_block_binding_fields(fields=internal_fields, current_schema=current_form or {})
@@ -992,6 +1241,84 @@ class AppFormCompiler:
                 self._data_relation_custom_button(config.get("customButton") or {}, template)
         self._data_relation_relations(profile, app_key, fields, internal_fields)
 
+    @staticmethod
+    def _assign_layout_temp_ids(body: list[Any], internal_fields: list[JSONObject]) -> None:
+        """Assign one temporary-ID sequence to fields and new section wrappers."""
+        temp_id = -10000
+        internal_index = 0
+
+        def assign_field(field: Any) -> None:
+            nonlocal temp_id, internal_index
+            if not isinstance(field, dict):
+                return
+            if internal_index >= len(internal_fields):
+                raise AppFormFailure(
+                    "INVALID_SPEC",
+                    "form layout and internal field list are inconsistent",
+                    "COMPILE",
+                )
+            internal = internal_fields[internal_index]
+            internal_index += 1
+            if _positive_int(field.get("queId")) is None:
+                internal["que_temp_id"] = temp_id
+            temp_id -= 100
+
+        for block in body:
+            if not isinstance(block, dict):
+                continue
+            if block.get("kind") == "row":
+                for field in block.get("fields") or []:
+                    assign_field(field)
+                continue
+            for row in block.get("rows") or []:
+                if not isinstance(row, dict):
+                    continue
+                for field in row.get("fields") or []:
+                    assign_field(field)
+            if _positive_int(block.get("sectionId")) is None:
+                temp_id -= 100
+
+        if internal_index != len(internal_fields):
+            raise AppFormFailure(
+                "INVALID_SPEC",
+                "form layout and internal field list are inconsistent",
+                "COMPILE",
+            )
+
+    @staticmethod
+    def _validate_unique_temp_ids(form_ques: list[list[JSONObject]]) -> None:
+        seen: dict[int, str] = {}
+
+        def visit(question: Any) -> None:
+            if not isinstance(question, dict):
+                return
+            temp_id = question.get("queTempId")
+            if temp_id is not None:
+                try:
+                    normalized = int(temp_id)
+                except (TypeError, ValueError):
+                    normalized = None
+                if normalized is not None:
+                    title = str(question.get("queTitle") or "")
+                    previous = seen.get(normalized)
+                    if previous is not None:
+                        raise AppFormFailure(
+                            "DUPLICATE_TEMP_ID",
+                            "form payload contains duplicate queTempId",
+                            "COMPILE",
+                            details={"queTempId": normalized, "questions": [previous, title]},
+                        )
+                    seen[normalized] = title
+            for subquestion in question.get("subQuestions") or []:
+                visit(subquestion)
+            for inner_row in question.get("innerQuestions") or []:
+                for inner_question in inner_row if isinstance(inner_row, list) else []:
+                    visit(inner_question)
+
+        for row in form_ques:
+            for question in row if isinstance(row, list) else []:
+                visit(question)
+
     def _target_body(self, current_body: list[Any], declared_body: list[Any]) -> list[JSONObject]:
         current_fields = list(_iter_fields(current_body))
         by_id = {_positive_int(field.get("queId")): field for field in current_fields if _positive_int(field.get("queId"))}
@@ -1012,6 +1339,12 @@ class AppFormCompiler:
                 target["config"] = deepcopy(declared["config"])
             target.setdefault("required", False)
             target.setdefault("description", None)
+            if target.get("defaultValue") is not None:
+                target.setdefault("defaultType", 1)
+            if "defaultValue" in declared and declared.get("defaultValue") is None:
+                target.pop("defaultType", None)
+                target.pop("defaultValue", None)
+                target["_clear_default_value"] = True
             if current is not None:
                 target["queId"] = current.get("queId")
             else:
@@ -1157,6 +1490,7 @@ class AppFormCompiler:
         target_fields = list(_iter_fields(target["spec"]["body"]))
         templates = self._question_templates(current_form)
         internal_fields = [self._internal_field(field, templates=templates) for field in target_fields]
+        self._assign_layout_temp_ids(target["spec"]["body"], internal_fields)
         try:
             internal_fields, _ = _normalize_and_validate_code_block_fields_for_write(fields=internal_fields)
             internal_fields, relations = _compile_code_block_binding_fields(fields=internal_fields, current_schema=current_form)
@@ -1176,6 +1510,12 @@ class AppFormCompiler:
             for relation in relations
             if _positive_int(relation.get("relationType")) != 1
         ]
+        payload["selectScopeRelations"] = [
+            self._select_scope_relation(profile, field, internal)
+            for field, internal in _iter_field_pairs(target_fields, internal_fields)
+            if isinstance(field.get("config"), dict)
+            and (field.get("config", {}).get("memberScopeRelation") or field.get("config", {}).get("departmentScopeRelation"))
+        ]
         rows: list[list[JSONObject]] = []
         temp_id = -10000
         for block in target["spec"]["body"]:
@@ -1212,11 +1552,13 @@ class AppFormCompiler:
                     temp_id -= 100
                 rows.append([section])
         payload["formQues"] = rows
+        self._validate_unique_temp_ids(rows)
         data_title = next((field for field in target_fields if field.get("dataTitle")), None)
         data_cover = next((field for field in target_fields if field.get("dataCover")), None)
         payload["dataTitleQueId"] = self._field_runtime_id(data_title, internal_fields)
         payload["dataCoverQueId"] = self._field_runtime_id(data_cover, internal_fields) if data_cover else None
         payload["questionRelations"].extend(data_relations)
+        _normalize_formula_defaults_for_save(payload.get("formQues"))
         return payload
 
     @staticmethod
@@ -1377,6 +1719,15 @@ class AppFormCompiler:
             "subfields": [self._internal_field(item, templates=templates) for item in field.get("subfields") or []],
             "_app_form_type": canonical_type,
         }
+        if "defaultValues" in config:
+            result["default_values"] = deepcopy(config.get("defaultValues"))
+        if "defaultType" in field:
+            result["default_type"] = _positive_int(field.get("defaultType")) or 1
+        if "defaultValue" in field:
+            result["default_value"] = deepcopy(field.get("defaultValue"))
+        if field.get("_clear_default_value") is True:
+            result["default_type"] = 1
+            result["default_value"] = None
         template = templates.get(result["que_id"] or -1)
         if template is not None:
             result["_question_template"] = deepcopy(template)
@@ -1390,6 +1741,19 @@ class AppFormCompiler:
                 ],
                 "include_sub_departs": bool(scope.get("includeSubDeparts")),
             }
+            default_departments = config.get("defaultDepartments")
+            if isinstance(default_departments, dict):
+                result["department_default_scope"] = {
+                    "departments": [
+                        {"dept_id": item.get("deptId"), "dept_name": item.get("deptName")}
+                        for item in default_departments.get("departments") or []
+                        if isinstance(item, dict)
+                    ],
+                    "include_sub_departs": bool(default_departments.get("includeSubDeparts")),
+                }
+        elif canonical_type == "member":
+            result["member_scope"] = deepcopy(config.get("memberScope"))
+            result["member_default_scope"] = deepcopy(config.get("defaultMembers"))
         elif canonical_type == "relation":
             result.update(
                 {
@@ -1397,6 +1761,8 @@ class AppFormCompiler:
                     "relation_mode": config.get("relationMode") or "single",
                     "display_field": _snake_selector(config.get("displayField")),
                     "visible_fields": [_snake_selector(item) for item in config.get("visibleFields") or []],
+                    "reference_default_formula_auto_fill": config.get("beingDefaultFormulaAutoFillEnabled"),
+                    "reference_default_value_match_rules": deepcopy(config.get("defaultValueMatchRules")),
                     "_relation_config_explicit": True,
                 }
             )
@@ -1443,6 +1809,87 @@ class AppFormCompiler:
                 "queHint": field.get("description") or "",
             }
         )
+        config = field.get("config") if isinstance(field.get("config"), dict) else {}
+        if field_type in {"text", "long_text", "link", "phone", "email"}:
+            for key in ("minWordCount", "maxWordCount", "noRepeat", "canScan", "scanType"):
+                if key in config:
+                    question[key] = _backend_unlimited(config[key]) if key in {"minWordCount", "maxWordCount"} else config[key]
+            if field_type == "phone":
+                for key in ("msgValidateStatus", "fixedPhone"):
+                    if key in config:
+                        question[key] = config[key]
+        elif field_type in {"number", "amount"}:
+            for key in ("numberLimitStatus", "minValue", "maxValue", "decimalDigit", "numberFormat", "currencyStatus", "currencyType", "canDecimal", "noRepeat", "canScan", "scanType"):
+                if key in config:
+                    question[key] = config[key]
+            if field_type == "amount" and "canDecimal" not in question:
+                question["canDecimal"] = True
+        elif field_type in CHOICE_TYPES:
+            for key in ("minOpts", "maxOpts", "optDirection", "optSelectMode", "beingShowColor"):
+                if key in config:
+                    question[key] = _backend_unlimited(config[key]) if key in {"minOpts", "maxOpts"} else config[key]
+        elif field_type == "member":
+            scope = config.get("memberScope")
+            default_scope = config.get("defaultMembers")
+            if isinstance(scope, dict):
+                question["memberSelectScopeType"] = {"all": 1, "custom": 2, "relation": 3}.get(scope.get("mode"), 1)
+                question["memberSelectScope"] = _backend_member_scope(scope)
+            if isinstance(default_scope, dict):
+                question["memberDftValue"] = _backend_member_scope(default_scope)
+            for key in ("noRepeat", "canScan", "scanType"):
+                if key in config:
+                    question[key] = config[key]
+        elif field_type == "department":
+            scope = config.get("departmentScope") if isinstance(config.get("departmentScope"), dict) else None
+            if scope is not None:
+                question["deptSelectScopeType"] = {"all": 1, "custom": 2, "relation": 3}.get(scope.get("mode"), 1)
+                question["deptSelectScope"] = {
+                    "depart": [
+                        _without_none({"deptId": item.get("deptId"), "deptName": item.get("deptName")})
+                        for item in scope.get("departments") or []
+                        if isinstance(item, dict)
+                    ],
+                    "includeSubDeparts": bool(scope.get("includeSubDeparts")),
+                }
+            default_scope = config.get("defaultDepartments")
+            if isinstance(default_scope, dict):
+                question["deptDftValue"] = {
+                    "depart": [
+                        _without_none({"deptId": item.get("deptId"), "deptName": item.get("deptName")})
+                        for item in default_scope.get("departments") or []
+                        if isinstance(item, dict)
+                    ],
+                    "includeSubDeparts": bool(default_scope.get("includeSubDeparts")),
+                }
+            for key in ("noRepeat", "canScan", "scanType", "beingShowParentPath"):
+                if key in config:
+                    question[key] = config[key]
+        elif field_type == "attachment":
+            for key in ("fileSize", "fileType", "fileBeingCaptureOnly", "imageCompress", "pluginStatus", "maxFileLimitStatus", "maxFileLimit", "canScan", "scanType"):
+                if key in config:
+                    question[key] = deepcopy(config[key])
+        elif field_type == "address":
+            for key in ("addressPrecision", "pickPosition", "canScan", "scanType"):
+                if key in config:
+                    question[key] = config[key]
+        elif field_type == "subtable":
+            for key in ("tableRowsLimit", "tableNoRepeatStatus", "tableRowHeight"):
+                if key in config:
+                    question[key] = deepcopy(config[key])
+            if isinstance(config.get("tableNoRepeatQuestion"), list):
+                question["tableNoRepeatQuestion"] = [
+                    self._resolve_subfield_runtime_id(item, internal.get("subfields") or [], "tableNoRepeatQuestion")
+                    for item in config["tableNoRepeatQuestion"]
+                ]
+        if "defaultValues" in config:
+            question["queDefaultValues"] = deepcopy(config.get("defaultValues"))
+        if "defaultType" in field:
+            question["queDefaultType"] = _positive_int(field.get("defaultType")) or 1
+        if "defaultValue" in field:
+            question["queDefaultValue"] = deepcopy(field.get("defaultValue"))
+        if field.get("_clear_default_value") is True:
+            question["queDefaultType"] = 1
+            question["queDefaultValue"] = None
         if field_type == "date":
             question["dateType"] = 0
         elif field_type == "datetime":
@@ -1460,7 +1907,10 @@ class AppFormCompiler:
                     option.update({key: deepcopy(value) for key, value in old.items() if key not in {"optValue"}})
             question["options"] = options
             question["unnamedOptions"] = [item.get("optValue") for item in options]
-            question["optDirection"] = 0
+            default_options = (field.get("config") or {}).get("defaultOptions")
+            if isinstance(default_options, list):
+                for option in options:
+                    option["beingDefault"] = str(option.get("optValue")) in {str(item) for item in default_options}
         elif field_type == "subtable":
             question["subQuestions"] = [
                 self._question(profile, app_key, subfield, sub_internal, temp_id - ((index + 1) * 10), relations)
@@ -1522,10 +1972,56 @@ class AppFormCompiler:
                 for index, item in enumerate(visible)
                 ],
                 "referAuthQues": [{"queId": item["queId"], "queAuth": 1} for item in visible],
+                "beingDefaultFormulaAutoFillEnabled": config.get("beingDefaultFormulaAutoFillEnabled"),
+                "defaultValueMatchRules": deepcopy(config.get("defaultValueMatchRules")),
             }
         )
+        if "defaultValues" in config:
+            result["queDefaultValues"] = deepcopy(config.get("defaultValues"))
         return result
 
+    def _select_scope_relation(self, profile: str, field: JSONObject, internal: JSONObject) -> JSONObject:
+        config = field.get("config") if isinstance(field.get("config"), dict) else {}
+        relation = config.get("memberScopeRelation") or config.get("departmentScopeRelation")
+        if not isinstance(relation, dict):
+            raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", "select scope relation must be an object", "COMPILE")
+        target_app_key = str(relation.get("targetAppKey") or "")
+        if not target_app_key:
+            raise AppFormFailure("UNSUPPORTED_FIELD_CONFIG", "select scope relation requires targetAppKey", "COMPILE")
+        target_form = self._read_form(profile, target_app_key, being_draft=False)
+        candidates = _backend_question_candidates(target_form)
+        displayed = _resolve_backend_selector(relation.get("displayedField") or {}, candidates, "selectScopeRelation.displayedField")
+        payload: JSONObject = {
+            "queId": _positive_int(internal.get("que_id")) or int(internal.get("que_temp_id") or 0),
+            "displayedQueId": _positive_int(displayed.get("queId")),
+            "displayedQueInfo": {
+                "appKey": target_app_key,
+                "appTitle": relation.get("targetAppTitle") or target_form.get("formTitle") or "",
+                "queId": _positive_int(displayed.get("queId")),
+                "queTitle": displayed.get("queTitle") or "",
+                "queType": _positive_int(displayed.get("queType")) or 2,
+            },
+        }
+        for key in ("matchRuleType", "matchRules", "matchRuleFormula"):
+            if key in relation:
+                payload[key] = deepcopy(relation.get(key))
+        return _without_none(payload)
+
+    @staticmethod
+    def _resolve_subfield_runtime_id(selector: JSONObject, internal_fields: list[JSONObject], location: str) -> int:
+        if not isinstance(selector, dict):
+            raise AppFormFailure("INVALID_FIELD_SELECTOR", f"{location} must be an object", "COMPILE")
+        que_id = _positive_int(selector.get("queId"))
+        name = str(selector.get("name") or "")
+        matches = [
+            item for item in internal_fields
+            if (que_id is None or _positive_int(item.get("que_id")) == que_id)
+            and (not name or str(item.get("name") or "") == name)
+        ]
+        if len(matches) != 1:
+            raise AppFormFailure("INVALID_FIELD_SELECTOR", f"{location} must resolve to exactly one subfield", "COMPILE", details={"selector": selector, "matches": len(matches)})
+        return _positive_int(matches[0].get("que_id")) or int(matches[0].get("que_temp_id") or 0)
+
     @staticmethod
     def _data_relation_custom_button(config: JSONObject, template: JSONObject | None) -> JSONObject:
         current = (template or {}).get("customButtonConfig")
@@ -1823,7 +2319,7 @@ class AppFormCompiler:
 
     @staticmethod
     def _save_base(current: JSONObject) -> JSONObject:
-        read_only = {"appKey", "formId", "baseQues", "applyAuthType", "canCurrentApply", "wsType", "accountLevel", "collectionStatus", "editVersionNo", "formQues", "questionRelations"}
+        read_only = {"appKey", "formId", "baseQues", "applyAuthType", "canCurrentApply", "wsType", "accountLevel", "collectionStatus", "editVersionNo", "formQues", "questionRelations", "selectScopeRelations"}
         return {key: deepcopy(value) for key, value in current.items() if key not in read_only}
 
     def _apply_form_settings(self, payload: JSONObject, *, current_form: JSONObject, target_spec: JSONObject, internal_fields: list[JSONObject]) -> None:
@@ -2664,17 +3160,34 @@ class AppFormReconciler:
 
     @staticmethod
     def _failure(error_code: str, message: str, phase: str, *, status: str = "failed", details: JSONObject | None = None, diagnostics: JSONObject | None = None, app_key: str | None = None, warnings: list[JSONObject] | None = None) -> JSONObject:
+        output_diagnostics = deepcopy(diagnostics or {})
+        for key in ("diff", "remainingDiff"):
+            if key in output_diagnostics:
+                output_diagnostics[key] = AppFormReconciler._compact_diff(output_diagnostics[key])
         result = {
             "status": status,
             "error_code": error_code,
             "recoverable": status != "failed" or error_code in {"PUBLISH_FAILED", "PACKAGE_ATTACH_RESULT_UNKNOWN"},
             "message": message,
-            **(diagnostics or {}),
+            **output_diagnostics,
             "phase": phase,
             **({"appKey": app_key} if app_key else {}),
-            **({"details": details} if details else {}),
             **({"warnings": warnings} if warnings else {}),
         }
+        if details:
+            # Apply diagnostics are already exposed at the top level. Keep only
+            # additional error context in details to avoid returning the same
+            # large diagnostic object twice.
+            compact_details = {
+                key: value
+                for key, value in details.items()
+                if key not in result
+            }
+            for key in ("diff", "remainingDiff"):
+                if key in compact_details:
+                    compact_details[key] = AppFormReconciler._compact_diff(compact_details[key])
+            if compact_details:
+                result["details"] = compact_details
         recovery = {
             "EDIT_VERSION_CONFLICT": "read the latest draft, rebuild the complete declaration, validate, and retry once",
             "EDIT_FINISHED_FAILED": "if published equals draft, release the current account's edit lock without publishing again",
@@ -2686,6 +3199,22 @@ class AppFormReconciler:
             result["recoveryHint"] = recovery
         return result
 
+    @staticmethod
+    def _compact_diff(diff: Any) -> Any:
+        if not isinstance(diff, dict):
+            return diff
+        compact = deepcopy(diff)
+        for key in ("added", "updated", "removed"):
+            fields = compact.get(key)
+            if not isinstance(fields, list):
+                continue
+            compact[key] = [
+                str(field.get("name") or field.get("queId") or "unknown") if isinstance(field, dict) else str(field)
+                for field in fields
+                if isinstance(field, (dict, str, int))
+            ]
+        return compact
+
     @classmethod
     def _from_error(cls, error: AppFormContractError | AppFormFailure) -> JSONObject:
         if isinstance(error, AppFormContractError):