@qingflow-tech/qingflow-app-user-mcp 1.0.2 → 1.0.3

package/src/qingflow_mcp/builder_facade/service.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
+import base64
 from copy import deepcopy
 from dataclasses import dataclass, field
 import json
 import os
+import random
 import re
+import string
 import tempfile
 from typing import Any, cast
+from urllib.parse import quote_plus, unquote_plus
 from uuid import uuid4
 
 from ..backend_client import BackendRequestContext
@@ -143,6 +147,7 @@ JUDGE_EQUAL_ANY = 9
 JUDGE_FUZZY_MATCH = 19
 JUDGE_INCLUDE_ANY = 20
 DEFAULT_TYPE_RELATION = 2
+DEFAULT_TYPE_FORMULA = 3
 RELATION_TYPE_Q_LINKER = 2
 RELATION_TYPE_CODE_BLOCK = 3
 
@@ -440,6 +445,7 @@ class AiBuilderFacade:
         base = base_result.get("result") if isinstance(base_result.get("result"), dict) else {}
         summary = detail_result.get("summary") if isinstance(detail_result, dict) and isinstance(detail_result.get("summary"), dict) else {}
         source = detail if detail else base
+        layout_tag_items = _select_package_layout_tag_items(detail=detail, base=base)
         warnings: list[JSONObject] = []
         if detail_read_error is not None:
             warnings.append(
@@ -450,7 +456,7 @@ class AiBuilderFacade:
                     "http_status": detail_read_error.http_status,
                 }
             )
-        public_items = _public_package_items_from_tag_items(source.get("tagItems") or base.get("tagItems"))
+        public_items = _public_package_items_from_tag_items(layout_tag_items)
         item_count = summary.get("itemCount")
         if not isinstance(item_count, int) or item_count < 0 or (item_count == 0 and public_items):
             item_count = len(public_items)
@@ -508,6 +514,8 @@ class AiBuilderFacade:
         }
         effective_package_id = _coerce_positive_int(package_id)
         created = False
+        create_result: JSONObject | None = None
+        update_result: JSONObject | None = None
         permission_outcomes: list[PermissionCheckOutcome] = []
 
         if effective_package_id is None:
@@ -598,11 +606,36 @@ class AiBuilderFacade:
                 )
             except VisibilityResolutionError:
                 expected_visibility = None
+        metadata_verified = True
+        if metadata_requested and update_result is not None:
+            metadata_verified = bool(update_result.get("verified"))
+        elif created and create_result is not None:
+            metadata_verified = bool(create_result.get("verified"))
+        layout_verified = True
+        if items is not None and layout_result is not None:
+            layout_verified = bool(layout_result.get("verified"))
+        response_verification: JSONObject = {
+            "package_exists": True,
+            "package_created": created,
+            "layout_applied": items is not None,
+            "metadata_verified": metadata_verified,
+            "layout_verified": layout_verified,
+            "visibility_verified": None
+            if expected_visibility is None
+            else _visibility_matches_expected(verification.get("visibility"), expected_visibility),
+        }
+        if isinstance(update_result, dict):
+            update_verification = update_result.get("verification")
+            if isinstance(update_verification, dict):
+                for key in ("package_name_verified", "package_icon_verified", "visibility_verified"):
+                    if key in update_verification:
+                        response_verification[key] = deepcopy(update_verification.get(key))
+        response_verified = metadata_verified and layout_verified and response_verification.get("visibility_verified") is not False
         response: JSONObject = {
-            "status": "success",
+            "status": "success" if response_verified else "partial_success",
             "error_code": None,
             "recoverable": False,
-            "message": "applied package",
+            "message": "applied package" if response_verified else "applied package with unverified readback",
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {},
@@ -611,15 +644,8 @@ class AiBuilderFacade:
             "suggested_next_call": None,
             "noop": not (created or metadata_requested or items is not None),
             "warnings": [],
-            "verification": {
-                "package_exists": True,
-                "package_created": created,
-                "layout_applied": items is not None,
-                "visibility_verified": None
-                if expected_visibility is None
-                else _visibility_matches_expected(verification.get("visibility"), expected_visibility),
-            },
-            "verified": True,
+            "verification": response_verification,
+            "verified": response_verified,
             **{
                 key: deepcopy(value)
                 for key, value in verification.items()
@@ -677,7 +703,7 @@ class AiBuilderFacade:
             )
         raw_current = current.get("result") if isinstance(current.get("result"), dict) else {}
         raw_current_base = current_base.get("result") if isinstance(current_base.get("result"), dict) else {}
-        current_name = str(raw_current.get("tagName") or "").strip() or None
+        current_name = str(raw_current.get("tagName") or raw_current_base.get("tagName") or "").strip() or None
         desired_name = str(package_name or current_name or "").strip() or current_name or "未命名应用包"
         desired_icon = encode_workspace_icon_with_defaults(
             icon=icon,
@@ -718,27 +744,33 @@ class AiBuilderFacade:
         verification = self.package_get(profile=profile, package_id=tag_id)
         if verification.get("status") != "success":
             return verification
+        package_name_verified = str(verification.get("package_name") or "").strip() == desired_name
+        package_icon_verified = str(verification.get("icon") or "").strip() == desired_icon
+        visibility_verified = _visibility_matches_expected(
+            verification.get("visibility"),
+            _public_visibility_from_member_auth(desired_auth),
+        )
+        verified = package_name_verified and package_icon_verified and visibility_verified
         return {
-            "status": "success",
+            "status": "success" if verified else "partial_success",
             "error_code": None,
             "recoverable": False,
-            "message": "updated package",
+            "message": "updated package" if verified else "updated package with unverified readback",
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {},
             "details": {},
             "request_id": update_result.get("request_id") if isinstance(update_result, dict) else None,
-            "suggested_next_call": None,
+            "suggested_next_call": None if verified else {"tool_name": "package_get", "arguments": {"profile": profile, "package_id": tag_id}},
             "noop": False,
             "warnings": [],
             "verification": {
                 "package_exists": True,
-                "visibility_verified": _visibility_matches_expected(
-                    verification.get("visibility"),
-                    _public_visibility_from_member_auth(desired_auth),
-                ),
+                "package_name_verified": package_name_verified,
+                "package_icon_verified": package_icon_verified,
+                "visibility_verified": visibility_verified,
             },
-            "verified": True,
+            "verified": verified,
             **{
                 key: deepcopy(value)
                 for key, value in verification.items()
@@ -881,9 +913,7 @@ class AiBuilderFacade:
             if isinstance(current_base_result, dict) and isinstance(current_base_result.get("result"), dict)
             else {}
         )
-        detail_tag_items = detail_raw.get("tagItems") if isinstance(detail_raw.get("tagItems"), list) else None
-        base_tag_items = base_raw.get("tagItems") if isinstance(base_raw.get("tagItems"), list) else None
-        raw_tag_items = detail_tag_items if detail_tag_items else base_tag_items
+        raw_tag_items = _select_package_layout_tag_items(detail=detail_raw, base=base_raw)
         if not isinstance(raw_tag_items, list):
             return _failed(
                 "PACKAGE_LAYOUT_UNREADABLE",
@@ -1409,6 +1439,8 @@ class AiBuilderFacade:
         issues: list[dict[str, Any]] = []
         resolved: list[dict[str, Any]] = []
         seen_ids: set[int] = set()
+        if not dept_ids and not dept_names:
+            return {"department_entries": resolved, "issues": issues}
         listed = self.directory.directory_list_all_departments(
             profile=profile,
             parent_dept_id=None,
@@ -2780,6 +2812,19 @@ class AiBuilderFacade:
             "can_copy_app": _coerce_optional_bool(base.get("copyAppStatus")),
         }
 
+    def _derive_can_edit_app_base(self, *, profile: str, permission_summary: JSONObject) -> bool:
+        if permission_summary.get("can_edit_app") is not True:
+            return False
+        tag_ids = _coerce_int_list(permission_summary.get("tag_ids"))
+        for tag_id in tag_ids:
+            try:
+                package_permission = self._read_package_permission_summary(profile=profile, tag_id=tag_id)
+            except (QingflowApiError, RuntimeError):
+                return False
+            if package_permission.get("can_edit_tag") is not True:
+                return False
+        return True
+
     def _read_portal_permission_summary(self, *, dash_key: str, portal_result: dict[str, Any]) -> JSONObject:
         tag_ids = _coerce_int_list(portal_result.get("tagIds"))
         if not tag_ids:
@@ -2993,7 +3038,7 @@ class AiBuilderFacade:
 
     def app_read_summary(self, *, profile: str, app_key: str) -> JSONObject:
         try:
-            state = self._load_base_schema_state(profile=profile, app_key=app_key)
+            base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True)
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
             return _failed_from_api_error(
@@ -3003,26 +3048,55 @@ class AiBuilderFacade:
                 details={"app_key": app_key},
                 suggested_next_call={"tool_name": "app_resolve", "arguments": {"profile": profile, "app_key": app_key}},
             )
-        views, views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
-        workflow, workflow_unavailable = self._load_workflow_result(profile=profile, app_key=app_key, tolerate_404=True)
-        parsed = state["parsed"]
+        base_result = base.get("result") if isinstance(base.get("result"), dict) else {}
+        schema_unavailable = False
+        try:
+            schema_result, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
+            parsed = _parse_schema(schema_result)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            if api_error.http_status == 404 or _is_permission_restricted_api_error(api_error):
+                schema_unavailable = True
+                parsed = {"fields": [], "layout": {"sections": []}}
+            else:
+                return _failed_from_api_error(
+                    "APP_READ_FAILED",
+                    api_error,
+                    normalized_args={"app_key": app_key},
+                    details={"app_key": app_key},
+                    suggested_next_call={"tool_name": "app_resolve", "arguments": {"profile": profile, "app_key": app_key}},
+                )
+        views, views_unavailable = self._load_views_result(
+            profile=profile,
+            app_key=app_key,
+            tolerate_404=True,
+            tolerate_permission_restricted=True,
+        )
+        workflow, workflow_unavailable = self._load_workflow_result(
+            profile=profile,
+            app_key=app_key,
+            tolerate_404=True,
+            tolerate_permission_restricted=True,
+        )
         verification_hints = _build_verification_hints(
-            tag_ids=_coerce_int_list(state["base"].get("tagIds")),
+            tag_ids=_coerce_int_list(base_result.get("tagIds")),
             fields=parsed["fields"],
             layout=parsed["layout"],
             views=_summarize_views(views),
         )
+        if schema_unavailable:
+            verification_hints.append("schema_read_unavailable")
         if views_unavailable:
             verification_hints.append("views_read_unavailable")
         if workflow_unavailable:
             verification_hints.append("workflow_read_unavailable")
         response = AppReadSummaryResponse(
             app_key=app_key,
-            title=state["base"].get("formTitle"),
-            app_icon=str(state["base"].get("appIcon") or "").strip() or None,
-            visibility=_public_visibility_from_member_auth(state["base"].get("auth")),
-            tag_ids=_coerce_int_list(state["base"].get("tagIds")),
-            publish_status=state["base"].get("appPublishStatus"),
+            title=base_result.get("formTitle"),
+            app_icon=str(base_result.get("appIcon") or "").strip() or None,
+            visibility=_public_visibility_from_member_auth(base_result.get("auth")),
+            tag_ids=_coerce_int_list(base_result.get("tagIds")),
+            publish_status=base_result.get("appPublishStatus"),
             field_count=len(parsed["fields"]),
             layout_section_count=len(parsed["layout"].get("sections", [])),
             view_count=len(_summarize_views(views)),
@@ -3044,10 +3118,11 @@ class AiBuilderFacade:
             "warnings": _warnings_from_verification_hints(verification_hints),
             "verification": {
                 "app_exists": True,
+                "schema_read_unavailable": schema_unavailable,
                 "views_read_unavailable": views_unavailable,
                 "workflow_read_unavailable": workflow_unavailable,
             },
-            "verified": not views_unavailable and not workflow_unavailable,
+            "verified": not schema_unavailable and not views_unavailable and not workflow_unavailable,
             **response.model_dump(mode="json"),
         }
 
@@ -3060,8 +3135,9 @@ class AiBuilderFacade:
         permission_summary = self._read_app_permission_summary(profile=profile, app_key=app_key)
         result["message"] = "read app config summary"
         result["editability"] = {
+            "can_edit_app_base": self._derive_can_edit_app_base(profile=profile, permission_summary=permission_summary),
             "can_edit_form": permission_summary.get("can_edit_app"),
-            "can_edit_flow": permission_summary.get("can_edit_app"),
+            "can_edit_flow": permission_summary.get("can_manage_data"),
             "can_edit_views": permission_summary.get("can_manage_data"),
             "can_edit_charts": permission_summary.get("can_manage_data"),
         }
@@ -4630,7 +4706,19 @@ class AiBuilderFacade:
                 )
             field = current_fields[matched]
             previous_name = field["name"]
-            _apply_field_mutation(field, patch.set)
+            try:
+                _apply_field_mutation(field, patch.set)
+            except ValueError as error:
+                return _failed(
+                    "VALIDATION_ERROR",
+                    str(error),
+                    normalized_args=normalized_args,
+                    details={
+                        "selector": patch.selector.model_dump(mode="json"),
+                        "app_key": target.app_key,
+                    },
+                    suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+                )
             current_fields[matched] = field
             layout = _rename_field_in_layout(layout, previous_name, field["name"])
             updated.append(field["name"])
@@ -4789,12 +4877,22 @@ class AiBuilderFacade:
             response = _apply_permission_outcomes(response, relation_permission_outcome)
             return finalize(self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response))
 
-        payload = _build_form_payload_from_fields(
-            title=effective_app_name,
-            current_schema=schema_result,
-            fields=current_fields,
-            layout=layout,
-            question_relations=compiled_question_relations,
+        payload = (
+            _build_form_payload_from_fields(
+                title=effective_app_name,
+                current_schema=schema_result,
+                fields=current_fields,
+                layout=layout,
+                question_relations=compiled_question_relations,
+            )
+            if bool(resolved.get("created"))
+            else _build_form_payload_for_edit_fields(
+                title=effective_app_name,
+                current_schema=schema_result,
+                fields=current_fields,
+                layout=layout,
+                question_relations=compiled_question_relations,
+            )
         )
         payload["editVersionNo"] = self._resolve_form_edit_version(
             profile=profile,
@@ -4897,12 +4995,22 @@ class AiBuilderFacade:
                     },
                     suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
                 )
-            rebound_payload = _build_form_payload_from_fields(
-                title=effective_app_name,
-                current_schema=rebound_schema,
-                fields=rebound_fields,
-                layout=rebound_layout,
-                question_relations=compiled_question_relations,
+            rebound_payload = (
+                _build_form_payload_from_fields(
+                    title=effective_app_name,
+                    current_schema=rebound_schema,
+                    fields=rebound_fields,
+                    layout=rebound_layout,
+                    question_relations=compiled_question_relations,
+                )
+                if bool(resolved.get("created"))
+                else _build_form_payload_for_edit_fields(
+                    title=effective_app_name,
+                    current_schema=rebound_schema,
+                    fields=rebound_fields,
+                    layout=rebound_layout,
+                    question_relations=compiled_question_relations,
+                )
             )
             rebound_payload["editVersionNo"] = self._resolve_form_edit_version(
                 profile=profile,
@@ -6670,6 +6778,7 @@ class AiBuilderFacade:
 
         for patch in request.upsert_charts:
             try:
+                config_update_requested = _chart_patch_updates_chart_config(patch)
                 chart_visible_auth = (
                     self._compile_visibility_to_chart_visible_auth(profile=profile, visibility=patch.visibility)
                     if patch.visibility is not None
@@ -6773,18 +6882,17 @@ class AiBuilderFacade:
                             existing_by_name.pop(old_name, None)
                     existing_by_name.setdefault(patch.name, []).append(deepcopy(updated_chart))
 
-                config_payload = _build_public_chart_config_payload(
-                    patch=patch,
-                    app_key=app_key,
-                    field_lookup=field_lookup,
-                    qingbi_fields_by_id=qingbi_fields_by_id,
-                )
-                if isinstance(chart_visible_auth, dict):
-                    raw_data_config = config_payload.get("rawDataConfigDTO")
-                    if isinstance(raw_data_config, dict):
-                        raw_data_config["authInfo"] = deepcopy(chart_visible_auth)
-                self.charts.qingbi_report_update_config(profile=profile, chart_id=chart_id, payload=config_payload)
-                if existing is not None and chart_id not in updated_ids:
+                config_updated = False
+                if existing is None or config_update_requested:
+                    config_payload = _build_public_chart_config_payload(
+                        patch=patch,
+                        app_key=app_key,
+                        field_lookup=field_lookup,
+                        qingbi_fields_by_id=qingbi_fields_by_id,
+                    )
+                    self.charts.qingbi_report_update_config(profile=profile, chart_id=chart_id, payload=config_payload)
+                    config_updated = True
+                if existing is not None and chart_id not in updated_ids and config_updated:
                     updated_ids.append(chart_id)
                 if patch.question_config:
                     self._request_backend(
@@ -6800,6 +6908,8 @@ class AiBuilderFacade:
                         path=f"/chart/{chart_id}/user/config",
                         json_body=patch.user_config,
                     )
+                if existing is not None and chart_id not in updated_ids and (patch.question_config or patch.user_config):
+                    updated_ids.append(chart_id)
                 chart_results.append(
                     {
                         "chart_id": chart_id,
@@ -6956,11 +7066,12 @@ class AiBuilderFacade:
         permission_outcomes: list[PermissionCheckOutcome] = []
         dash_key = str(request.dash_key or "").strip()
         creating = not dash_key
+        sections_requested = creating or bool(request.sections)
         verify_dash_name = creating or request.dash_name is not None
         verify_dash_icon = bool(request.icon or request.color)
         verify_auth = request.visibility is not None or request.auth is not None
-        verify_hide_copyright = request.hide_copyright is not None
-        verify_dash_global_config = request.dash_global_config is not None
+        verify_hide_copyright = request.hide_copyright is not None and sections_requested
+        verify_dash_global_config = request.dash_global_config is not None and sections_requested
         verify_tags = creating or request.package_tag_id is not None
         requested_visibility = request.visibility
         if requested_visibility is None and isinstance(request.auth, dict) and request.auth:
@@ -7037,6 +7148,25 @@ class AiBuilderFacade:
             if package_edit_outcome.block is not None:
                 return package_edit_outcome.block
             permission_outcomes.append(package_edit_outcome)
+        if not sections_requested:
+            unsupported_base_only_keys: list[str] = []
+            if request.hide_copyright is not None:
+                unsupported_base_only_keys.append("hide_copyright")
+            if request.dash_global_config is not None:
+                unsupported_base_only_keys.append("dash_global_config")
+            if request.config:
+                unsupported_base_only_keys.append("config")
+            if unsupported_base_only_keys:
+                return _failed(
+                    "PORTAL_SECTIONS_REQUIRED",
+                    "editing a portal without sections only supports base-info updates",
+                    normalized_args=normalized_args,
+                    details={
+                        "unsupported_without_sections": unsupported_base_only_keys,
+                        "fix_hint": "Pass sections when changing layout or global portal config, or omit those keys for visibility/icon/package updates.",
+                    },
+                    suggested_next_call={"tool_name": "portal_apply", "arguments": {"profile": profile, **normalized_args}},
+                )
         try:
             if creating:
                 create_payload = _build_public_portal_base_payload(
@@ -7062,7 +7192,6 @@ class AiBuilderFacade:
                         suggested_next_call={"tool_name": "portal_apply", "arguments": {"profile": profile, **normalized_args}},
                     )
                 base_payload = self.portals.portal_get(profile=profile, dash_key=dash_key, being_draft=True).get("result") or {}
-            component_payload = self._build_portal_components_from_sections(profile=profile, sections=request.sections)
             update_payload = _build_public_portal_base_payload(
                 dash_name=request.dash_name or str(base_payload.get("dashName") or "").strip() or "未命名门户",
                 package_tag_id=target_package_tag_id,
@@ -7074,8 +7203,10 @@ class AiBuilderFacade:
                 config=request.config,
                 base_payload=base_payload,
             )
-            update_payload["components"] = component_payload
-            self.portals.portal_update(profile=profile, dash_key=dash_key, payload=update_payload)
+            if sections_requested:
+                component_payload = self._build_portal_components_from_sections(profile=profile, sections=request.sections)
+                update_payload["components"] = component_payload
+                self.portals.portal_update(profile=profile, dash_key=dash_key, payload=update_payload)
             self.portals.portal_update_base_info(
                 profile=profile,
                 dash_key=dash_key,
@@ -7112,11 +7243,14 @@ class AiBuilderFacade:
                 publish_failed = True
 
         draft_components = draft_result.get("components") if isinstance(draft_result, dict) else None
-        expected_count = len(request.sections)
-        draft_verified = isinstance(draft_components, list) and len(draft_components) == expected_count
+        expected_count = len(request.sections) if sections_requested else None
+        draft_verified = isinstance(draft_result, dict) and (
+            expected_count is None or (isinstance(draft_components, list) and len(draft_components) == expected_count)
+        )
         draft_meta_verified, draft_meta_mismatches = _verify_portal_readback(
             actual=draft_result,
             expected_payload=update_payload,
+            expected_visibility=requested_visibility.model_dump(mode="json") if requested_visibility is not None else None,
             expected_section_count=expected_count,
             requested_config_keys=set((request.config or {}).keys()),
             verify_dash_name=verify_dash_name,
@@ -7132,12 +7266,18 @@ class AiBuilderFacade:
         if request.publish:
             live_verified = (
                 isinstance(live_result, dict)
-                and isinstance(live_result.get("components"), list)
-                and len(live_result.get("components")) == expected_count
+                and (
+                    expected_count is None
+                    or (
+                        isinstance(live_result.get("components"), list)
+                        and len(live_result.get("components")) == expected_count
+                    )
+                )
             )
             live_meta_verified, live_meta_mismatches = _verify_portal_readback(
                 actual=live_result,
                 expected_payload=update_payload,
+                expected_visibility=requested_visibility.model_dump(mode="json") if requested_visibility is not None else None,
                 expected_section_count=expected_count,
                 requested_config_keys=set((request.config or {}).keys()),
                 verify_dash_name=verify_dash_name,
@@ -7171,7 +7311,15 @@ class AiBuilderFacade:
             "status": status,
             "error_code": error_code,
             "recoverable": not verified,
-            "message": "applied portal" if verified else "applied portal; draft/live verification pending",
+            "message": (
+                "updated portal base info"
+                if verified and not sections_requested
+                else "applied portal"
+                if verified
+                else "updated portal base info; draft/live verification pending"
+                if not sections_requested
+                else "applied portal; draft/live verification pending"
+            ),
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {"section.source_type": ["chart", "view", "grid", "filter", "text", "link"]},
@@ -7366,17 +7514,35 @@ class AiBuilderFacade:
             sync_result = {**sync_result, "button_config_restored": True}
         return sync_result
 
-    def _load_views_result(self, *, profile: str, app_key: str, tolerate_404: bool) -> tuple[Any, bool]:
+    def _load_views_result(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        tolerate_404: bool,
+        tolerate_permission_restricted: bool = False,
+    ) -> tuple[Any, bool]:
         try:
             views = self.views.view_list_flat(profile=profile, app_key=app_key)
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
-            if api_error.http_status == 404:
+            if api_error.http_status == 404 or (
+                tolerate_permission_restricted and _is_permission_restricted_api_error(api_error)
+            ):
                 try:
                     legacy_views = self.views.view_list(profile=profile, app_key=app_key)
                 except (QingflowApiError, RuntimeError) as legacy_error:
                     legacy_api_error = _coerce_api_error(legacy_error)
-                    if tolerate_404 and legacy_api_error.http_status == 404:
+                    if (
+                        tolerate_404
+                        and (
+                            legacy_api_error.http_status == 404
+                            or (
+                                tolerate_permission_restricted
+                                and _is_permission_restricted_api_error(legacy_api_error)
+                            )
+                        )
+                    ):
                         return [], True
                     raise
                 legacy_result = legacy_views.get("result")
@@ -7393,19 +7559,38 @@ class AiBuilderFacade:
             legacy_views = self.views.view_list(profile=profile, app_key=app_key)
         except (QingflowApiError, RuntimeError) as legacy_error:
             legacy_api_error = _coerce_api_error(legacy_error)
-            if tolerate_404 and legacy_api_error.http_status == 404:
+            if (
+                tolerate_404
+                and (
+                    legacy_api_error.http_status == 404
+                    or (
+                        tolerate_permission_restricted
+                        and _is_permission_restricted_api_error(legacy_api_error)
+                    )
+                )
+            ):
                 return normalized_views, False
             raise
         legacy_result = legacy_views.get("result")
         legacy_normalized = _normalize_view_collection(legacy_result)
         return legacy_normalized or normalized_views, False
 
-    def _load_workflow_result(self, *, profile: str, app_key: str, tolerate_404: bool) -> tuple[Any, bool]:
+    def _load_workflow_result(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        tolerate_404: bool,
+        tolerate_permission_restricted: bool = False,
+    ) -> tuple[Any, bool]:
         try:
             workflow = self.workflows.workflow_list_nodes(profile=profile, app_key=app_key)
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
-            if tolerate_404 and api_error.http_status == 404:
+            if tolerate_404 and (
+                api_error.http_status == 404
+                or (tolerate_permission_restricted and _is_permission_restricted_api_error(api_error))
+            ):
                 return [], True
             raise
         return workflow.get("result"), False
@@ -8697,6 +8882,11 @@ def _build_public_chart_config_payload(
     return payload
 
 
+def _chart_patch_updates_chart_config(patch: ChartUpsertPatch) -> bool:
+    explicit_fields = set(getattr(patch, "model_fields_set", set()) or set())
+    return bool({"dimension_field_ids", "indicator_field_ids", "filters", "config"} & explicit_fields)
+
+
 def _build_public_portal_base_payload(
     *,
     dash_name: str,
@@ -8926,7 +9116,8 @@ def _verify_portal_readback(
     *,
     actual: Any,
     expected_payload: dict[str, Any],
-    expected_section_count: int,
+    expected_visibility: dict[str, Any] | None,
+    expected_section_count: int | None,
     requested_config_keys: set[str],
     verify_dash_name: bool,
     verify_dash_icon: bool,
@@ -8939,14 +9130,19 @@ def _verify_portal_readback(
     if not isinstance(actual, dict):
         return False, ["portal readback payload is unavailable"]
     components = actual.get("components")
-    if not isinstance(components, list) or len(components) != expected_section_count:
+    if expected_section_count is not None and (not isinstance(components, list) or len(components) != expected_section_count):
         mismatches.append(f"components expected {expected_section_count}, got {len(components) if isinstance(components, list) else 'unavailable'}")
     if verify_dash_name and str(actual.get("dashName") or "").strip() != str(expected_payload.get("dashName") or "").strip():
         mismatches.append("dash_name")
     if verify_dash_icon and str(actual.get("dashIcon") or "") != str(expected_payload.get("dashIcon") or ""):
         mismatches.append("dash_icon")
-    if verify_auth and not _mapping_contains(actual.get("auth"), expected_payload.get("auth")):
-        mismatches.append("auth")
+    if verify_auth:
+        if expected_visibility is not None:
+            actual_visibility = _public_visibility_from_member_auth(actual.get("auth"))
+            if not _visibility_matches_expected(actual_visibility, expected_visibility):
+                mismatches.append("auth")
+        elif not _mapping_contains(actual.get("auth"), expected_payload.get("auth")):
+            mismatches.append("auth")
     if verify_hide_copyright and bool(actual.get("hideCopyright", False)) != bool(expected_payload.get("hideCopyright", False)):
         mismatches.append("hide_copyright")
     if verify_dash_global_config and not _mapping_contains(actual.get("dashGlobalConfig") or {}, expected_payload.get("dashGlobalConfig") or {}):
@@ -9154,7 +9350,11 @@ def _visibility_matches_expected(actual: Any, expected: Any) -> bool:
         if expected_text and sorted_values(actual_group, text_key) != expected_text:
             return False
 
-    if "include_sub_departs" in expected_selectors and actual_selectors.get("include_sub_departs") != expected_selectors.get("include_sub_departs"):
+    if (
+        "include_sub_departs" in expected_selectors
+        and expected_selectors.get("include_sub_departs") is not None
+        and actual_selectors.get("include_sub_departs") != expected_selectors.get("include_sub_departs")
+    ):
         return False
     return True
 
@@ -9611,6 +9811,15 @@ def _apply_relation_target_selection(
     config["refer_field_types"] = [item.get("type") for item in normalized_visible]
     config["auth_field_ids"] = [item.get("field_id") or item.get("name") for item in normalized_visible]
     config["auth_field_que_ids"] = [_coerce_positive_int(item.get("que_id")) or 0 for item in normalized_visible]
+    config["refer_auth_ques"] = [
+        {
+            "queId": _coerce_positive_int(item.get("que_id")) or 0,
+            "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH,
+            "_field_id": item.get("field_id") or item.get("name"),
+        }
+        for item in normalized_visible
+        if (_coerce_positive_int(item.get("que_id")) or 0) > 0
+    ]
     config["field_name_show"] = bool(field.get("field_name_show", True))
     field["target_field_id"] = display_field.get("field_id") or display_field.get("name")
     field["target_field_que_id"] = _coerce_positive_int(display_field.get("que_id")) or 0
@@ -9844,9 +10053,10 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         "subfields": [],
         "que_id": que_id,
         "que_type": que_type,
-        "default_type": _coerce_positive_int(question.get("queDefaultType")) or 1,
-        "default_value": question.get("queDefaultValue"),
+        "default_type": _coerce_positive_int(question.get("queDefaultType")) if "queDefaultType" in question else None,
     }
+    if "queDefaultValue" in question:
+        field["default_value"] = question.get("queDefaultValue")
     if field_type in {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value}:
         options = question.get("options")
         if isinstance(options, list):
@@ -9870,17 +10080,32 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         field["target_app_key"] = reference.get("referAppKey")
         field["relation_mode"] = _relation_mode_from_optional_data_num(reference.get("optionalDataNum"))
         refer_questions = reference.get("referQuestions") if isinstance(reference.get("referQuestions"), list) else []
+        refer_auth_questions = reference.get("referAuthQues") if isinstance(reference.get("referAuthQues"), list) else []
+        refer_auth_by_que_id: dict[int, int] = {}
+        for raw_item in refer_auth_questions:
+            if not isinstance(raw_item, dict):
+                continue
+            que_id = _coerce_nonnegative_int(raw_item.get("queId"))
+            que_auth = _coerce_nonnegative_int(raw_item.get("queAuth"))
+            if que_id is None or que_auth is None or que_id in refer_auth_by_que_id:
+                continue
+            refer_auth_by_que_id[que_id] = que_auth
         visible_fields: list[dict[str, Any]] = []
         display_field_que_id = _coerce_nonnegative_int(reference.get("referQueId"))
         display_field_name: str | None = None
         for item in refer_questions:
             if not isinstance(item, dict):
                 continue
+            que_id = _coerce_nonnegative_int(item.get("queId"))
+            que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+            if que_auth is None and que_id is not None:
+                que_auth = refer_auth_by_que_id.get(que_id)
             selector = {
-                "que_id": _coerce_nonnegative_int(item.get("queId")),
+                "que_id": que_id,
                 "name": str(item.get("queTitle") or "").strip() or None,
             }
-            visible_fields.append(selector)
+            if que_auth != _REFERENCE_FIELD_HIDDEN_AUTH:
+                visible_fields.append(selector)
             if display_field_que_id is not None and selector["que_id"] == display_field_que_id:
                 display_field_name = selector["name"]
         if display_field_name is None and visible_fields:
@@ -9960,6 +10185,7 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
                 continue
             subfields.append(_parse_field(sub_question))
         field["subfields"] = subfields
+    field["_question_template"] = deepcopy(question)
     return field
 
 
@@ -10505,14 +10731,14 @@ def _parse_code_block_inputs_and_body(code_content: str) -> tuple[list[dict[str,
     return inputs, body
 
 
-def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any]) -> dict[str, Any]:
+def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any], nested: bool = False) -> dict[str, Any]:
     payload = {
         "field_id": field.get("field_id"),
         "que_id": field.get("que_id"),
         "name": field.get("name"),
         "type": field.get("type"),
         "required": bool(field.get("required")),
-        "section_id": _find_field_section_id(layout, str(field.get("name") or "")),
+        "section_id": None if nested else _find_field_section_id(layout, str(field.get("name") or "")),
     }
     if field.get("type") == FieldType.relation.value:
         payload["target_app_key"] = field.get("target_app_key")
@@ -10545,6 +10771,12 @@ def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any])
             payload["custom_button_text"] = field.get("custom_button_text")
         if field.get("metadata_unverified") is not None:
             payload["metadata_unverified"] = bool(field.get("metadata_unverified"))
+    if field.get("type") == FieldType.subtable.value:
+        payload["subfields"] = [
+            _compact_public_field_read(field=subfield, layout=layout, nested=True)
+            for subfield in cast(list[dict[str, Any]], field.get("subfields") or [])
+            if isinstance(subfield, dict)
+        ]
     return payload
 
 
@@ -10840,59 +11072,119 @@ def _code_block_binding_equal(left: Any, right: Any) -> bool:
     return _normalize_code_block_binding(left) == _normalize_code_block_binding(right)
 
 
+_SAFE_SUBFIELD_MUTATION_KEYS = frozenset({"name", "required", "description", "subfield_updates"})
+
+
+def _validate_safe_subfield_mutation(*, payload: dict[str, Any], location: str) -> None:
+    unsupported = sorted(key for key in payload if key not in _SAFE_SUBFIELD_MUTATION_KEYS)
+    if unsupported:
+        raise ValueError(
+            f"{location} only supports safe overlay keys: name, required, description, subfield_updates; "
+            f"unsupported keys: {', '.join(unsupported)}"
+        )
+
+
+def _apply_subfield_updates(field: dict[str, Any], raw_updates: list[Any]) -> None:
+    if str(field.get("type") or "") != FieldType.subtable.value:
+        raise ValueError("subfield_updates can only target subtable fields")
+    subfields = [subfield for subfield in cast(list[dict[str, Any]], field.get("subfields") or []) if isinstance(subfield, dict)]
+    for index, raw_item in enumerate(raw_updates):
+        patch = FieldUpdatePatch.model_validate(raw_item)
+        payload = patch.set.model_dump(mode="json", exclude_none=True)
+        _validate_safe_subfield_mutation(payload=payload, location=f"subfield_updates[{index}].set")
+        target = _resolve_field_selector_with_uniqueness(
+            fields=subfields,
+            selector_payload=patch.selector.model_dump(mode="json", exclude_none=True),
+            location=f"subfield_updates[{index}].selector",
+        )
+        _apply_field_mutation(target, patch.set)
+    field["subfields"] = subfields
+
+
 def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
     payload = mutation.model_dump(mode="json", exclude_none=True)
     relation_config_explicit = (
         payload.get("type") == FieldType.relation.value
         or any(key in payload for key in ("target_app_key", "display_field", "visible_fields", "relation_mode"))
     )
+    question_overlay_keys = set(cast(list[str], field.get("_question_overlay_keys") or []))
+    question_rebuild_required = bool(field.get("_question_rebuild_required"))
     if "name" in payload:
         field["name"] = payload["name"]
+        question_overlay_keys.add("name")
     if "type" in payload:
         field["type"] = payload["type"]
+        question_rebuild_required = True
     if "required" in payload:
         field["required"] = payload["required"]
+        question_overlay_keys.add("required")
     if "description" in payload:
         field["description"] = payload["description"]
+        question_overlay_keys.add("description")
     if "options" in payload:
         field["options"] = list(payload["options"])
+        question_rebuild_required = True
     if "target_app_key" in payload:
         field["target_app_key"] = payload["target_app_key"]
+        question_rebuild_required = True
     if "display_field" in payload:
         field["display_field"] = payload["display_field"]
+        question_rebuild_required = True
     if "visible_fields" in payload:
         field["visible_fields"] = list(payload["visible_fields"])
+        question_rebuild_required = True
     if "relation_mode" in payload:
         field["relation_mode"] = payload["relation_mode"]
+        question_rebuild_required = True
     if "department_scope" in payload:
         field["department_scope"] = payload["department_scope"]
+        question_rebuild_required = True
     if "remote_lookup_config" in payload:
         field["remote_lookup_config"] = payload["remote_lookup_config"]
         field["config"] = deepcopy(payload["remote_lookup_config"])
         field["_explicit_remote_lookup_config"] = True
+        question_rebuild_required = True
     if "q_linker_binding" in payload:
         field["q_linker_binding"] = payload["q_linker_binding"]
         if "remote_lookup_config" not in payload:
             field["_explicit_remote_lookup_config"] = False
+        question_rebuild_required = True
     if "code_block_config" in payload:
         field["code_block_config"] = payload["code_block_config"]
         field["config"] = deepcopy(payload["code_block_config"])
+        question_rebuild_required = True
     if "code_block_binding" in payload:
         field["code_block_binding"] = payload["code_block_binding"]
         field["_explicit_code_block_binding"] = True
+        question_rebuild_required = True
     if "auto_trigger" in payload:
         field["auto_trigger"] = payload["auto_trigger"]
+        question_rebuild_required = True
     if "custom_button_text_enabled" in payload:
         field["custom_button_text_enabled"] = payload["custom_button_text_enabled"]
+        question_rebuild_required = True
     if "custom_button_text" in payload:
         field["custom_button_text"] = payload["custom_button_text"]
+        question_rebuild_required = True
     if "subfields" in payload:
         field["subfields"] = [_field_patch_to_internal(item) for item in payload["subfields"]]
+        question_rebuild_required = True
+    if "subfield_updates" in payload:
+        _apply_subfield_updates(field, payload["subfield_updates"])
     if relation_config_explicit:
         field["_relation_config_explicit"] = True
+        question_rebuild_required = True
     elif payload.get("type") and payload.get("type") != FieldType.relation.value:
         field.pop("_relation_config_explicit", None)
         field.pop("_reference_config_template", None)
+    if question_overlay_keys:
+        field["_question_overlay_keys"] = sorted(question_overlay_keys)
+    else:
+        field.pop("_question_overlay_keys", None)
+    if question_rebuild_required:
+        field["_question_rebuild_required"] = True
+    else:
+        field.pop("_question_rebuild_required", None)
 
 
 def _resolve_field_selector_with_uniqueness(
@@ -12080,6 +12372,7 @@ def _warnings_from_verification_hints(hints: list[str]) -> list[dict[str, Any]]:
         "package attachment not verified": _warning("PACKAGE_ATTACHMENT_UNVERIFIED", "package attachment is not verified"),
         "layout has unplaced fields": _warning("LAYOUT_HAS_UNPLACED_FIELDS", "layout still contains unplaced fields"),
         "no public views detected": _warning("NO_PUBLIC_VIEWS", "no public views were detected"),
+        "schema_read_unavailable": _warning("SCHEMA_READ_UNAVAILABLE", "schema summary readback is unavailable"),
         "views_read_unavailable": _warning("VIEWS_READ_UNAVAILABLE", "views summary readback is unavailable"),
         "workflow_read_unavailable": _warning("WORKFLOW_READ_UNAVAILABLE", "workflow summary readback is unavailable"),
     }
@@ -12380,6 +12673,26 @@ def _public_package_items_from_tag_items(tag_items: Any) -> list[JSONObject]:
     return public_items
 
 
+def _select_package_layout_tag_items(*, detail: Any, base: Any) -> list[Any] | None:
+    base_tag_items = base.get("tagItems") if isinstance(base, dict) and isinstance(base.get("tagItems"), list) else None
+    detail_tag_items = detail.get("tagItems") if isinstance(detail, dict) and isinstance(detail.get("tagItems"), list) else None
+    if _package_tag_items_include_groups(base_tag_items):
+        return deepcopy(base_tag_items)
+    if _package_tag_items_include_groups(detail_tag_items):
+        return deepcopy(detail_tag_items)
+    if detail_tag_items is not None:
+        return deepcopy(detail_tag_items)
+    if base_tag_items is not None:
+        return deepcopy(base_tag_items)
+    return None
+
+
+def _package_tag_items_include_groups(tag_items: Any) -> bool:
+    if not isinstance(tag_items, list):
+        return False
+    return any(isinstance(item, dict) and _coerce_positive_int(item.get("itemType")) == 3 for item in tag_items)
+
+
 def _flatten_package_resource_identities(items: Any, *, public: bool) -> set[tuple[str, str]]:
     flattened: set[tuple[str, str]] = set()
 
@@ -12690,8 +13003,887 @@ def _verify_package_attachment(packages: PackageTools, *, profile: str, tag_id:
     return last_result
 
 
+def _field_question_overlay_keys(field: dict[str, Any]) -> set[str]:
+    raw_value = field.get("_question_overlay_keys")
+    if isinstance(raw_value, set):
+        return {str(item) for item in raw_value if isinstance(item, str) and item}
+    if isinstance(raw_value, list):
+        return {str(item) for item in raw_value if isinstance(item, str) and item}
+    return set()
+
+
+def _field_needs_question_rebuild(field: dict[str, Any]) -> bool:
+    return not isinstance(field.get("_question_template"), dict) or bool(field.get("_question_rebuild_required"))
+
+
+def _extract_template_row_lengths(schema: dict[str, Any]) -> tuple[dict[int, int], dict[str, int]]:
+    lengths_by_que_id: dict[int, int] = {}
+    lengths_by_title: dict[str, int] = {}
+
+    def remember_row(row: Any) -> None:
+        if not isinstance(row, list):
+            return
+        questions = [question for question in row if isinstance(question, dict)]
+        row_length = len(questions)
+        if row_length <= 0:
+            return
+        for question in questions:
+            que_id = _coerce_nonnegative_int(question.get("queId"))
+            if que_id is not None:
+                lengths_by_que_id[que_id] = row_length
+            title = str(question.get("queTitle") or "").strip()
+            if title:
+                lengths_by_title[title] = row_length
+
+    for row in schema.get("formQues", []) or []:
+        if not isinstance(row, list):
+            continue
+        if len(row) == 1 and isinstance(row[0], dict) and _coerce_positive_int(row[0].get("queType")) == 24:
+            for inner_row in row[0].get("innerQuestions", []) or []:
+                remember_row(inner_row)
+            continue
+        remember_row(row)
+    return lengths_by_que_id, lengths_by_title
+
+
+def _field_template_row_length(
+    field: dict[str, Any],
+    *,
+    lengths_by_que_id: dict[int, int],
+    lengths_by_title: dict[str, int],
+) -> int | None:
+    que_id = _coerce_nonnegative_int(field.get("que_id"))
+    if que_id is not None and que_id in lengths_by_que_id:
+        return lengths_by_que_id[que_id]
+    template = field.get("_question_template")
+    if isinstance(template, dict):
+        template_que_id = _coerce_nonnegative_int(template.get("queId"))
+        if template_que_id is not None and template_que_id in lengths_by_que_id:
+            return lengths_by_que_id[template_que_id]
+        template_title = str(template.get("queTitle") or "").strip()
+        if template_title and template_title in lengths_by_title:
+            return lengths_by_title[template_title]
+    field_name = str(field.get("name") or "").strip()
+    if field_name and field_name in lengths_by_title:
+        return lengths_by_title[field_name]
+    return None
+
+
+def _row_needs_width_reflow(expected_template_lengths: list[int], current_row_length: int) -> bool:
+    if current_row_length <= 0:
+        return False
+    return any(length != current_row_length for length in expected_template_lengths)
+
+
+_FORM_SAVE_BASE_KEYS = (
+    "formDesc",
+    "formTheme",
+    "formAttach",
+    "formStyle",
+    "serialNumType",
+    "serialNumConfig",
+    "attachVisibleOnlyConfig",
+    "externalLang",
+    "hideCopyright",
+)
+
+_QUESTION_RELATION_SAVE_KEYS = (
+    "queId",
+    "relationType",
+    "displayedQueId",
+    "qlinkerAlias",
+    "displayedQueInfo",
+    "aliasConfig",
+    "matchRules",
+    "tableMatchRules",
+    "matchRuleType",
+    "matchRuleFormula",
+    "sortConfig",
+)
+
+_RELATION_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queTempId",
+    "queType",
+    "queOriginType",
+    "queTitle",
+    "queWidth",
+    "scanType",
+    "status",
+    "required",
+    "queHint",
+    "linkedQuestions",
+    "logicalShow",
+    "queDefaultType",
+    "queDefaultValue",
+    "queDefaultValues",
+    "subQueWidth",
+    "innerQuestions",
+    "minOpts",
+    "maxOpts",
+    "beingHide",
+    "beingDesensitized",
+    "relationDisplayMode",
+    "customRenderConfig",
+)
+
+_REFERENCE_CONFIG_SAVE_KEYS = (
+    "referAppKey",
+    "referQueId",
+    "customButtonText",
+    "beingTableSource",
+    "referMatchRules",
+    "canAddData",
+    "dataAdditionButtonText",
+    "canViewProcessLog",
+    "optionalDataNum",
+    "beingDataLogVisible",
+    "beingDefaultFormulaAutoFillEnabled",
+    "defaultValueMatchRules",
+    "configShowForm",
+    "configSortFieldId",
+    "configAsc",
+    "dataShowForm",
+    "defaultRow",
+    "fieldNameShow",
+    "dataSortFieldId",
+    "dataSortAsc",
+)
+
+_REFERENCE_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queTitle",
+    "queType",
+    "queAuth",
+    "ordinal",
+)
+
+_REFERENCE_FILL_RULE_SAVE_KEYS = (
+    "queId",
+    "relatedQueId",
+    "queTitle",
+    "relatedQueTitle",
+)
+
+_REFERENCE_AUTH_QUESTION_SAVE_KEYS = (
+    "queId",
+    "queAuth",
+)
+
+
+def _copy_present_keys(
+    source: dict[str, Any],
+    keys: tuple[str, ...],
+    *,
+    keep_none_keys: tuple[str, ...] = (),
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    keep_none = set(keep_none_keys)
+    for key in keys:
+        if key not in source:
+            continue
+        value = source.get(key)
+        if value is None and key not in keep_none:
+            continue
+        payload[key] = deepcopy(value)
+    return payload
+
+
+def _looks_like_backend_encoded_formula(value: str) -> bool:
+    if len(value) <= 32:
+        return False
+    encoded = value[16:-16]
+    if not encoded:
+        return False
+    try:
+        decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
+        unquote_plus(decoded)
+    except Exception:
+        return False
+    return True
+
+
+def _encode_formula_for_backend_save(value: Any) -> Any:
+    if not isinstance(value, str) or not value:
+        return value
+    if _looks_like_backend_encoded_formula(value):
+        return value
+    encoded = quote_plus(value, encoding="utf-8")
+    b64_value = base64.b64encode(encoded.encode("utf-8")).decode("ascii")
+    alphabet = string.ascii_letters + string.digits
+    prefix = "".join(random.choice(alphabet) for _ in range(16))
+    suffix = "".join(random.choice(alphabet) for _ in range(16))
+    return f"{prefix}{b64_value}{suffix}"
+
+
+def _normalize_formula_defaults_for_save(value: Any) -> None:
+    if isinstance(value, list):
+        for item in value:
+            _normalize_formula_defaults_for_save(item)
+        return
+    if not isinstance(value, dict):
+        return
+    if _coerce_any_int(value.get("queDefaultType")) == DEFAULT_TYPE_FORMULA and value.get("queDefaultValue"):
+        value["queDefaultValue"] = _encode_formula_for_backend_save(value.get("queDefaultValue"))
+    for key in ("subQuestions", "innerQuestions"):
+        nested = value.get(key)
+        if isinstance(nested, (list, dict)):
+            _normalize_formula_defaults_for_save(nested)
+
+
+def _normalize_reference_question_for_save(value: Any, *, ordinal: int) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_QUESTION_SAVE_KEYS)
+    que_id = _coerce_any_int(value.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    if "ordinal" not in payload:
+        payload["ordinal"] = _coerce_nonnegative_int(value.get("ordinal"))
+    if payload.get("ordinal") is None:
+        payload["ordinal"] = ordinal
+    if not any(key in payload for key in ("queId", "queTitle", "queType")):
+        return None
+    return payload
+
+
+def _normalize_reference_fill_rule_for_save(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_FILL_RULE_SAVE_KEYS)
+    que_id = _coerce_nonnegative_int(value.get("queId"))
+    related_que_id = _coerce_nonnegative_int(value.get("relatedQueId", value.get("referQueId")))
+    if que_id is not None:
+        payload["queId"] = que_id
+    if related_que_id is not None:
+        payload["relatedQueId"] = related_que_id
+    if "relatedQueTitle" not in payload and value.get("referQueTitle") is not None:
+        payload["relatedQueTitle"] = str(value.get("referQueTitle") or "")
+    if "queId" not in payload or "relatedQueId" not in payload:
+        return None
+    return payload
+
+
+def _normalize_reference_auth_question_for_save(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = _copy_present_keys(value, _REFERENCE_AUTH_QUESTION_SAVE_KEYS)
+    que_id = _coerce_any_int(value.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    que_auth = _coerce_nonnegative_int(value.get("queAuth"))
+    if que_auth is not None:
+        payload["queAuth"] = que_auth
+    sub_ques = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], value.get("subQues") or [])
+        )
+        if item is not None
+    ]
+    inner_ques = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], value.get("innerQues") or [])
+        )
+        if item is not None
+    ]
+    if sub_ques or "subQues" in value:
+        payload["subQues"] = sub_ques
+    if inner_ques or "innerQues" in value:
+        payload["innerQues"] = inner_ques
+    if "queId" not in payload or "queAuth" not in payload:
+        return None
+    return payload
+
+
+def _dedupe_reference_auth_questions(auth_questions: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    deduped: list[dict[str, Any]] = []
+    seen_que_ids: set[int] = set()
+    for item in auth_questions:
+        normalized_item = _normalize_reference_auth_question_for_save(item)
+        if normalized_item is None:
+            continue
+        que_id = _coerce_any_int(normalized_item.get("queId"))
+        if que_id is None or que_id in seen_que_ids:
+            continue
+        seen_que_ids.add(que_id)
+        deduped.append(normalized_item)
+    return deduped
+
+
+_REFERENCE_FIELD_HIDDEN_AUTH = 2
+_REFERENCE_FIELD_VISIBLE_AUTH = 3
+
+
+def _synthesize_reference_auth_questions_for_save(
+    *,
+    source: dict[str, Any],
+    field: dict[str, Any],
+) -> list[dict[str, Any]]:
+    config = field.get("config") if isinstance(field.get("config"), dict) else {}
+    synthesized: list[dict[str, Any]] = []
+
+    if isinstance(config.get("refer_auth_ques"), list):
+        synthesized.extend(cast(list[dict[str, Any]], config.get("refer_auth_ques") or []))
+    if synthesized:
+        return _dedupe_reference_auth_questions(synthesized)
+
+    refer_question_ids_by_name: dict[str, int] = {}
+    for raw_item in cast(list[Any], source.get("referQuestions") or []):
+        if not isinstance(raw_item, dict):
+            continue
+        que_id = _coerce_any_int(raw_item.get("queId"))
+        name = str(raw_item.get("queTitle") or "").strip()
+        if que_id is None or not name or name in refer_question_ids_by_name:
+            continue
+        refer_question_ids_by_name[name] = que_id
+
+    visible_fields = cast(list[dict[str, Any]], field.get("visible_fields") or [])
+    for item in visible_fields:
+        if not isinstance(item, dict):
+            continue
+        que_id = _coerce_any_int(item.get("que_id"))
+        if que_id is None:
+            name = str(item.get("name") or "").strip()
+            que_id = refer_question_ids_by_name.get(name)
+        if que_id is None:
+            continue
+        synthesized.append({"queId": que_id, "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH})
+    if synthesized:
+        return _dedupe_reference_auth_questions(synthesized)
+
+    auth_field_que_ids = cast(list[Any], config.get("auth_field_que_ids") or [])
+    for raw_que_id in auth_field_que_ids:
+        que_id = _coerce_any_int(raw_que_id)
+        if que_id is None:
+            continue
+        synthesized.append({"queId": que_id, "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH})
+    if synthesized:
+        return _dedupe_reference_auth_questions(synthesized)
+
+    for raw_item in cast(list[Any], source.get("referQuestions") or []):
+        if not isinstance(raw_item, dict):
+            continue
+        que_id = _coerce_any_int(raw_item.get("queId"))
+        if que_id is None:
+            continue
+        synthesized.append(
+            {
+                "queId": que_id,
+                "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH,
+            }
+        )
+    if synthesized:
+        return _dedupe_reference_auth_questions(synthesized)
+
+    fallback_que_id = _coerce_any_int(field.get("target_field_que_id"))
+    if fallback_que_id is not None:
+        synthesized.append({"queId": fallback_que_id, "queAuth": _REFERENCE_FIELD_VISIBLE_AUTH})
+    return _dedupe_reference_auth_questions(synthesized)
+
+
+def _reference_question_auth_overrides_for_save(
+    *,
+    source: dict[str, Any],
+    field: dict[str, Any],
+) -> dict[int, int]:
+    overrides: dict[int, int] = {}
+    visible_que_ids: set[int] = set()
+
+    for item in cast(list[Any], field.get("visible_fields") or []):
+        if not isinstance(item, dict):
+            continue
+        que_id = _coerce_any_int(item.get("que_id"))
+        if que_id is not None:
+            visible_que_ids.add(que_id)
+
+    if not visible_que_ids:
+        refer_auth_ques = _synthesize_reference_auth_questions_for_save(source=source, field=field)
+        for item in refer_auth_ques:
+            que_id = _coerce_any_int(item.get("queId"))
+            que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+            if que_id is None or que_auth is None:
+                continue
+            overrides[que_id] = que_auth
+        if overrides:
+            return overrides
+
+    for raw_item in cast(list[Any], source.get("referQuestions") or []):
+        if not isinstance(raw_item, dict):
+            continue
+        que_id = _coerce_any_int(raw_item.get("queId"))
+        if que_id is None:
+            continue
+        overrides[que_id] = (
+            _REFERENCE_FIELD_VISIBLE_AUTH if que_id in visible_que_ids else _REFERENCE_FIELD_HIDDEN_AUTH
+        )
+    return overrides
+
+
+def _reference_question_matches_visible_selector(question: dict[str, Any], selector: dict[str, Any]) -> bool:
+    question_que_id = _coerce_any_int(question.get("queId"))
+    selector_que_id = _coerce_any_int(selector.get("que_id"))
+    if question_que_id is not None and selector_que_id is not None and question_que_id == selector_que_id:
+        return True
+    question_name = str(question.get("queTitle") or "").strip()
+    selector_name = str(selector.get("name") or "").strip()
+    return bool(question_name and selector_name and question_name == selector_name)
+
+
+def _build_reference_question_from_visible_selector(
+    selector: dict[str, Any],
+    *,
+    ordinal: int,
+) -> dict[str, Any] | None:
+    return _normalize_reference_question_for_save(
+        {
+            "queId": _coerce_any_int(selector.get("que_id")),
+            "queTitle": str(selector.get("name") or "").strip() or None,
+            "queType": str(selector.get("type") or "2"),
+            "ordinal": ordinal,
+        },
+        ordinal=ordinal,
+    )
+
+
+def _canonicalize_reference_questions_for_save(
+    *,
+    source: dict[str, Any],
+    field: dict[str, Any],
+) -> list[dict[str, Any]]:
+    relation_config_explicit = bool(field.get("_relation_config_explicit"))
+    normalized_source_questions = [
+        item
+        for item in (
+            _normalize_reference_question_for_save(raw_item, ordinal=index)
+            for index, raw_item in enumerate(cast(list[Any], source.get("referQuestions") or []), start=1)
+        )
+        if item is not None
+    ]
+    if not relation_config_explicit:
+        return normalized_source_questions
+
+    display_field = field.get("display_field") if isinstance(field.get("display_field"), dict) else None
+    visible_fields = [item for item in cast(list[Any], field.get("visible_fields") or []) if isinstance(item, dict)]
+    ordered_visible_selectors: list[dict[str, Any]] = []
+    if display_field is not None:
+        ordered_visible_selectors.append(display_field)
+    for item in visible_fields:
+        if any(_relation_target_field_matches(existing, item) for existing in ordered_visible_selectors):
+            continue
+        ordered_visible_selectors.append(item)
+
+    if not ordered_visible_selectors:
+        return normalized_source_questions
+
+    canonical_questions: list[dict[str, Any]] = []
+    used_source_indexes: set[int] = set()
+
+    for ordinal, selector in enumerate(ordered_visible_selectors, start=1):
+        matched_index: int | None = None
+        matched_item: dict[str, Any] | None = None
+        for index, item in enumerate(normalized_source_questions):
+            if index in used_source_indexes:
+                continue
+            if _reference_question_matches_visible_selector(item, selector):
+                matched_index = index
+                matched_item = deepcopy(item)
+                break
+        if matched_item is None:
+            matched_item = _build_reference_question_from_visible_selector(selector, ordinal=ordinal)
+        if matched_item is None:
+            continue
+        matched_item["ordinal"] = ordinal
+        canonical_questions.append(matched_item)
+        if matched_index is not None:
+            used_source_indexes.add(matched_index)
+
+    source_target_app_key = str(source.get("referAppKey") or "").strip()
+    target_app_key = str(field.get("target_app_key") or "").strip()
+    preserve_remaining_source_questions = not source_target_app_key or source_target_app_key == target_app_key
+
+    if preserve_remaining_source_questions:
+        next_ordinal = len(canonical_questions) + 1
+        for index, item in enumerate(normalized_source_questions):
+            if index in used_source_indexes:
+                continue
+            remaining_item = deepcopy(item)
+            remaining_item["ordinal"] = next_ordinal
+            next_ordinal += 1
+            canonical_questions.append(remaining_item)
+
+    return canonical_questions
+
+
+def _canonicalize_reference_auth_questions_for_save(
+    *,
+    source: dict[str, Any],
+    refer_questions: list[dict[str, Any]],
+    relation_config_explicit: bool,
+) -> list[dict[str, Any]]:
+    source_auth_questions = [
+        item
+        for item in (
+            _normalize_reference_auth_question_for_save(raw_item)
+            for raw_item in cast(list[Any], source.get("referAuthQues") or [])
+        )
+        if item is not None
+    ]
+    source_auth_by_que_id: dict[int, dict[str, Any]] = {}
+    for item in source_auth_questions:
+        que_id = _coerce_any_int(item.get("queId"))
+        if que_id is None or que_id in source_auth_by_que_id:
+            continue
+        source_auth_by_que_id[que_id] = item
+
+    if not relation_config_explicit:
+        auth_questions: list[dict[str, Any]] = []
+        seen_que_ids: set[int] = set()
+        refer_question_auth_by_que_id: dict[int, int] = {}
+        for item in refer_questions:
+            que_id = _coerce_any_int(item.get("queId"))
+            que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+            if que_id is None or que_auth is None or que_id in refer_question_auth_by_que_id:
+                continue
+            refer_question_auth_by_que_id[que_id] = que_auth
+
+        for item in source_auth_questions:
+            que_id = _coerce_any_int(item.get("queId"))
+            if que_id is None or que_id in seen_que_ids:
+                continue
+            payload = deepcopy(item)
+            if que_id in refer_question_auth_by_que_id:
+                payload["queAuth"] = refer_question_auth_by_que_id[que_id]
+            auth_questions.append(payload)
+            seen_que_ids.add(que_id)
+
+        for item in refer_questions:
+            que_id = _coerce_any_int(item.get("queId"))
+            que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+            if que_id is None or que_auth is None or que_id in seen_que_ids:
+                continue
+            payload = deepcopy(source_auth_by_que_id.get(que_id) or {"queId": que_id})
+            payload["queId"] = que_id
+            payload["queAuth"] = que_auth
+            auth_questions.append(payload)
+            seen_que_ids.add(que_id)
+
+        return _dedupe_reference_auth_questions(auth_questions)
+
+    auth_questions: list[dict[str, Any]] = []
+    for item in refer_questions:
+        que_id = _coerce_any_int(item.get("queId"))
+        que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+        if que_id is None or que_auth is None:
+            continue
+        payload = deepcopy(source_auth_by_que_id.get(que_id) or {"queId": que_id})
+        payload["queId"] = que_id
+        payload["queAuth"] = que_auth
+        auth_questions.append(payload)
+    return _dedupe_reference_auth_questions(auth_questions)
+
+
+def _enforce_reference_config_consistency_for_save(
+    payload: dict[str, Any],
+    *,
+    field: dict[str, Any],
+) -> dict[str, Any]:
+    relation_config_explicit = bool(field.get("_relation_config_explicit"))
+    refer_questions = [
+        item
+        for item in (
+            _normalize_reference_question_for_save(raw_item, ordinal=index)
+            for index, raw_item in enumerate(cast(list[Any], payload.get("referQuestions") or []), start=1)
+        )
+        if item is not None
+    ]
+    if not refer_questions:
+        return payload
+
+    refer_auth_ques = _dedupe_reference_auth_questions(
+        [
+            item
+            for item in (
+                _normalize_reference_auth_question_for_save(raw_item)
+                for raw_item in cast(list[Any], payload.get("referAuthQues") or [])
+            )
+            if item is not None
+        ]
+    )
+    refer_auth_by_que_id: dict[int, int] = {}
+    for item in refer_auth_ques:
+        que_id = _coerce_any_int(item.get("queId"))
+        que_auth = _coerce_nonnegative_int(item.get("queAuth"))
+        if que_id is None or que_auth is None or que_id in refer_auth_by_que_id:
+            continue
+        refer_auth_by_que_id[que_id] = que_auth
+
+    display_field_que_id = _coerce_any_int(payload.get("referQueId"))
+    if display_field_que_id is None:
+        display_field_que_id = _coerce_any_int(field.get("target_field_que_id"))
+        if display_field_que_id is not None:
+            payload["referQueId"] = display_field_que_id
+
+    if relation_config_explicit:
+        if display_field_que_id is not None and not any(
+            _coerce_any_int(item.get("queId")) == display_field_que_id for item in refer_questions
+        ):
+            display_selector = field.get("display_field") if isinstance(field.get("display_field"), dict) else None
+            display_question = (
+                _build_reference_question_from_visible_selector(display_selector, ordinal=1)
+                if display_selector is not None
+                else None
+            )
+            if display_question is not None:
+                display_question["queId"] = display_field_que_id
+                display_question["queAuth"] = _REFERENCE_FIELD_VISIBLE_AUTH
+                refer_questions = [display_question, *refer_questions]
+
+        if display_field_que_id is not None:
+            display_questions = [
+                item for item in refer_questions if _coerce_any_int(item.get("queId")) == display_field_que_id
+            ]
+            trailing_questions = [
+                item for item in refer_questions if _coerce_any_int(item.get("queId")) != display_field_que_id
+            ]
+            refer_questions = [*display_questions, *trailing_questions]
+
+    for ordinal, item in enumerate(refer_questions, start=1):
+        que_id = _coerce_any_int(item.get("queId"))
+        if que_id is None:
+            continue
+        item["ordinal"] = ordinal
+        item["queAuth"] = refer_auth_by_que_id.get(
+            que_id,
+            _coerce_nonnegative_int(item.get("queAuth")) or _REFERENCE_FIELD_VISIBLE_AUTH,
+        )
+        if display_field_que_id is not None and que_id == display_field_que_id:
+            item["queAuth"] = _REFERENCE_FIELD_VISIBLE_AUTH
+
+    payload["referQuestions"] = refer_questions
+    payload["referAuthQues"] = _canonicalize_reference_auth_questions_for_save(
+        source={"referAuthQues": refer_auth_ques},
+        refer_questions=refer_questions,
+        relation_config_explicit=relation_config_explicit,
+    )
+    return payload
+
+
+def _normalize_reference_config_for_save(
+    reference: Any,
+    *,
+    field: dict[str, Any],
+) -> dict[str, Any]:
+    source = reference if isinstance(reference, dict) else {}
+    payload = _copy_present_keys(source, _REFERENCE_CONFIG_SAVE_KEYS)
+    if str(field.get("target_app_key") or "").strip():
+        payload["referAppKey"] = str(field.get("target_app_key") or "").strip()
+    if field.get("target_field_que_id") is not None:
+        payload["referQueId"] = _coerce_nonnegative_int(field.get("target_field_que_id"))
+    if field.get("field_name_show") is not None:
+        payload["fieldNameShow"] = bool(field.get("field_name_show"))
+
+    refer_question_auth_overrides = _reference_question_auth_overrides_for_save(source=source, field=field)
+    refer_questions = _canonicalize_reference_questions_for_save(source=source, field=field)
+    for index, normalized_item in enumerate(refer_questions, start=1):
+        que_id = _coerce_any_int(normalized_item.get("queId"))
+        if que_id is not None and que_id in refer_question_auth_overrides:
+            normalized_item["queAuth"] = refer_question_auth_overrides[que_id]
+        normalized_item["ordinal"] = index
+    if refer_questions or "referQuestions" in source:
+        payload["referQuestions"] = refer_questions
+
+    refer_fill_rules = [
+        item
+        for item in (
+            _normalize_reference_fill_rule_for_save(raw_item)
+            for raw_item in cast(list[Any], source.get("referFillRules") or [])
+        )
+        if item is not None
+    ]
+    if refer_fill_rules or "referFillRules" in source:
+        payload["referFillRules"] = refer_fill_rules
+
+    refer_auth_ques = _canonicalize_reference_auth_questions_for_save(
+        source=source,
+        refer_questions=refer_questions,
+        relation_config_explicit=bool(field.get("_relation_config_explicit")),
+    )
+    if not refer_auth_ques:
+        refer_auth_ques = _synthesize_reference_auth_questions_for_save(source=source, field=field)
+    if refer_auth_ques or "referAuthQues" in source:
+        payload["referAuthQues"] = refer_auth_ques
+
+    return _enforce_reference_config_consistency_for_save(payload, field=field)
+
+
+def _normalize_relation_question_for_save(question: dict[str, Any], *, field: dict[str, Any]) -> dict[str, Any]:
+    payload = _copy_present_keys(question, _RELATION_QUESTION_SAVE_KEYS)
+    overlay_keys = _field_question_overlay_keys(field)
+    que_id = _coerce_nonnegative_int(question.get("queId"))
+    if que_id is not None:
+        payload["queId"] = que_id
+    que_temp_id = _coerce_nonnegative_int(question.get("queTempId"))
+    if que_temp_id is not None and "queId" not in payload:
+        payload["queTempId"] = que_temp_id
+    payload["queType"] = _coerce_positive_int(question.get("queType")) or 25
+    payload["queTitle"] = str(field.get("name") or question.get("queTitle") or "")
+    if "required" in overlay_keys or "required" in question or field.get("required") is not None:
+        payload["required"] = bool(field.get("required", question.get("required", False)))
+    if "description" in overlay_keys:
+        payload["queHint"] = "" if field.get("description") is None else str(field.get("description"))
+    elif "queHint" in question and question.get("queHint") is not None:
+        payload["queHint"] = str(question.get("queHint") or "")
+    if field.get("default_type") is not None:
+        payload["queDefaultType"] = _coerce_positive_int(field.get("default_type")) or 1
+    if "default_value" in field:
+        payload["queDefaultValue"] = field.get("default_value")
+    payload["referenceConfig"] = _normalize_reference_config_for_save(question.get("referenceConfig"), field=field)
+    return payload
+
+
+def _build_form_save_base_payload(current_schema: dict[str, Any], title: str) -> dict[str, Any]:
+    payload: dict[str, Any] = {"formTitle": title}
+    for key in _FORM_SAVE_BASE_KEYS:
+        if key in current_schema:
+            payload[key] = deepcopy(current_schema.get(key))
+    payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
+    payload["formQues"] = []
+    payload["questionRelations"] = []
+    return payload
+
+
+def _normalize_question_relations_for_save(question_relations: list[dict[str, Any]] | None) -> list[dict[str, Any]]:
+    normalized: list[dict[str, Any]] = []
+    for relation in question_relations or []:
+        if not isinstance(relation, dict):
+            continue
+        item: dict[str, Any] = {}
+        for key in _QUESTION_RELATION_SAVE_KEYS:
+            if key not in relation:
+                continue
+            value = relation.get(key)
+            if value is None:
+                continue
+            if key == "matchRuleFormula":
+                value = _encode_formula_for_backend_save(value)
+            item[key] = deepcopy(value)
+        if item:
+            normalized.append(item)
+    return normalized
+
+
+def _field_rename_maps(fields: list[dict[str, Any]]) -> tuple[dict[int, str], dict[str, str]]:
+    by_que_id: dict[int, str] = {}
+    by_title: dict[str, str] = {}
+
+    def visit(field: dict[str, Any]) -> None:
+        if not isinstance(field, dict):
+            return
+        template = field.get("_question_template")
+        if not isinstance(template, dict):
+            for subfield in cast(list[dict[str, Any]], field.get("subfields") or []):
+                visit(subfield)
+            return
+        old_title = str(template.get("queTitle") or "").strip()
+        new_title = str(field.get("name") or "").strip()
+        if not old_title or not new_title or old_title == new_title:
+            for subfield in cast(list[dict[str, Any]], field.get("subfields") or []):
+                visit(subfield)
+            return
+        que_id = _coerce_nonnegative_int(field.get("que_id"))
+        if que_id is None:
+            que_id = _coerce_nonnegative_int(template.get("queId"))
+        if que_id is not None:
+            by_que_id[que_id] = new_title
+        by_title[old_title] = new_title
+        for subfield in cast(list[dict[str, Any]], field.get("subfields") or []):
+            visit(subfield)
+
+    for field in fields:
+        visit(field)
+    return by_que_id, by_title
+
+
+def _sync_question_title_references(value: Any, *, by_que_id: dict[int, str], by_title: dict[str, str]) -> None:
+    if isinstance(value, list):
+        for item in value:
+            _sync_question_title_references(item, by_que_id=by_que_id, by_title=by_title)
+        return
+    if not isinstance(value, dict):
+        return
+
+    title_keys = ("queTitle", "_field_id")
+    que_id = _coerce_nonnegative_int(value.get("queId"))
+    replacement = None
+    if que_id is not None and que_id in by_que_id:
+        replacement = by_que_id[que_id]
+    elif que_id is None:
+        for key in title_keys:
+            current_title = str(value.get(key) or "").strip()
+            if current_title and current_title in by_title:
+                replacement = by_title[current_title]
+                break
+    if replacement is not None:
+        for key in title_keys:
+            current_title = str(value.get(key) or "").strip()
+            if (que_id is not None and que_id in by_que_id and key in value) or (current_title and current_title in by_title):
+                value[key] = replacement
+    sup_id = _coerce_nonnegative_int(value.get("supId"))
+    if sup_id is not None and sup_id in by_que_id and "supQueTitle" in value:
+        value["supQueTitle"] = by_que_id[sup_id]
+
+    for child_value in value.values():
+        if isinstance(child_value, (dict, list)):
+            _sync_question_title_references(child_value, by_que_id=by_que_id, by_title=by_title)
+
+
+def _materialize_preserved_subtable_question(field: dict[str, Any], *, template: dict[str, Any]) -> dict[str, Any] | None:
+    materialized_subquestions: list[dict[str, Any]] = []
+    for subfield in cast(list[dict[str, Any]], field.get("subfields") or []):
+        if not isinstance(subfield, dict):
+            continue
+        materialized = _materialize_preserved_question(subfield)
+        if materialized is None:
+            return None
+        materialized_subquestions.append(materialized)
+    template["subQuestions"] = materialized_subquestions
+    template["innerQuestions"] = [deepcopy(materialized_subquestions)]
+    return template
+
+
+def _materialize_preserved_question(field: dict[str, Any]) -> dict[str, Any] | None:
+    template = deepcopy(field.get("_question_template"))
+    if not isinstance(template, dict):
+        return None
+    overlay_keys = _field_question_overlay_keys(field)
+    if "name" in overlay_keys:
+        template["queTitle"] = str(field.get("name") or "")
+    if "required" in overlay_keys:
+        template["required"] = bool(field.get("required", False))
+    if "description" in overlay_keys:
+        description = field.get("description")
+        template["queHint"] = "" if description is None else str(description)
+    if str(field.get("type") or "") == FieldType.subtable.value:
+        return _materialize_preserved_subtable_question(field, template=template)
+    if str(field.get("type") or "") == FieldType.relation.value:
+        return _normalize_relation_question_for_save(template, field=field)
+    return template
+
+
+def _materialize_edit_question(field: dict[str, Any], *, temp_id: int) -> tuple[dict[str, Any], bool]:
+    if not _field_needs_question_rebuild(field):
+        preserved = _materialize_preserved_question(field)
+        if preserved is not None:
+            return preserved, True
+    return _field_to_question(field, temp_id=temp_id), False
+
+
 def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]:
-    question, _next_temp_id = build_question(
+    built_question, _next_temp_id = build_question(
         {
             "label": field["name"],
             "type": field["type"],
@@ -12716,11 +13908,32 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
         },
         temp_id,
     )
+    relation_config_explicit = bool(field.get("_relation_config_explicit"))
+    relation_question_template = (
+        deepcopy(field.get("_question_template"))
+        if field.get("type") == FieldType.relation.value and isinstance(field.get("_question_template"), dict)
+        else None
+    )
+    question = (
+        relation_question_template
+        if relation_question_template is not None and not relation_config_explicit
+        else built_question
+    )
+    if relation_config_explicit and relation_question_template is not None:
+        for key in ("queOriginType", "relationDisplayMode", "customRenderConfig"):
+            if key in relation_question_template:
+                question[key] = deepcopy(relation_question_template[key])
     if _coerce_nonnegative_int(field.get("que_id")) is not None:
         question["queId"] = field["que_id"]
+        question.pop("queTempId", None)
     else:
+        question["queId"] = 0
         question["queTempId"] = temp_id
         field["que_temp_id"] = temp_id
+    question["queType"] = built_question.get("queType", question.get("queType"))
+    question["queTitle"] = built_question.get("queTitle", field["name"])
+    question["required"] = built_question.get("required", bool(field.get("required", False)))
+    question["queHint"] = built_question.get("queHint", field.get("description") or "")
     if field.get("default_type") is not None:
         question["queDefaultType"] = _coerce_positive_int(field.get("default_type")) or 1
     if "default_value" in field:
@@ -12728,21 +13941,60 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
     if field.get("type") == FieldType.relation.value:
         preserved_reference = (
             deepcopy(field.get("_reference_config_template"))
-            if not bool(field.get("_relation_config_explicit")) and isinstance(field.get("_reference_config_template"), dict)
+            if not relation_config_explicit and isinstance(field.get("_reference_config_template"), dict)
             else None
         )
         if preserved_reference is not None:
             preserved_reference["referAppKey"] = field.get("target_app_key")
-            preserved_reference["_targetEntityId"] = field.get("target_app_key")
             question["referenceConfig"] = preserved_reference
         else:
-            reference = question.get("referenceConfig") if isinstance(question.get("referenceConfig"), dict) else {}
+            existing_reference = (
+                deepcopy(relation_question_template.get("referenceConfig"))
+                if relation_question_template is not None and isinstance(relation_question_template.get("referenceConfig"), dict)
+                else deepcopy(question.get("referenceConfig"))
+                if isinstance(question.get("referenceConfig"), dict)
+                else {}
+            )
+            reference = (
+                existing_reference
+                if relation_config_explicit
+                else deepcopy(question.get("referenceConfig"))
+                if isinstance(question.get("referenceConfig"), dict)
+                else {}
+            )
+            built_reference = (
+                deepcopy(built_question.get("referenceConfig"))
+                if isinstance(built_question.get("referenceConfig"), dict)
+                else {}
+            )
+            original_target_app_key = str(existing_reference.get("referAppKey") or "").strip()
+            next_target_app_key = str(field.get("target_app_key") or "").strip()
+            preserve_existing_reference_questions = (
+                relation_config_explicit
+                and bool(original_target_app_key)
+                and original_target_app_key == next_target_app_key
+            )
+            if relation_config_explicit:
+                for stale_key in ("customButtonText", "customAdvancedSetting", "configShowForm", "dataShowForm"):
+                    reference.pop(stale_key, None)
+            for key in (
+                "referQueId",
+                "referQuestions",
+                "referAuthQues",
+                "optionalDataNum",
+                "fieldNameShow",
+                "_targetFieldId",
+            ):
+                if preserve_existing_reference_questions and key in {"referQuestions", "referAuthQues"}:
+                    continue
+                if key in built_reference:
+                    reference[key] = deepcopy(built_reference[key])
             reference["referAppKey"] = field.get("target_app_key")
             reference["_targetEntityId"] = field.get("target_app_key")
             if field.get("target_field_que_id") is not None:
                 reference["referQueId"] = field.get("target_field_que_id")
-            reference["optionalDataNum"] = _relation_mode_to_optional_data_num(field.get("relation_mode"))
             question["referenceConfig"] = reference
+        question = _normalize_relation_question_for_save(question, field=field)
     if field.get("type") == FieldType.department.value:
         scope_type, scope_payload = _serialize_department_scope_for_question(field.get("department_scope"))
         question["deptSelectScopeType"] = scope_type
@@ -12882,8 +14134,127 @@ def _build_form_payload_from_fields(
     for row in form_rows:
         _apply_row_widths(row)
     payload = default_form_payload(title, form_rows)
+    _normalize_formula_defaults_for_save(payload.get("formQues"))
+    payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
+    payload["questionRelations"] = _normalize_question_relations_for_save(
+        question_relations if question_relations is not None else (current_schema.get("questionRelations") or [])
+    )
+    return payload
+
+
+def _build_form_payload_for_edit_fields(
+    *,
+    title: str,
+    current_schema: dict[str, Any],
+    fields: list[dict[str, Any]],
+    layout: dict[str, Any],
+    question_relations: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    _, section_templates = _extract_question_templates(current_schema)
+    template_row_lengths_by_que_id, template_row_lengths_by_title = _extract_template_row_lengths(current_schema)
+    fields_by_name = {
+        str(field.get("name") or ""): field
+        for field in fields
+        if isinstance(field, dict) and str(field.get("name") or "").strip()
+    }
+    form_rows: list[list[dict[str, Any]]] = []
+    temp_id = -10000
+
+    for row in layout.get("root_rows", []) or []:
+        questions: list[dict[str, Any]] = []
+        expected_template_lengths: list[int] = []
+        row_preserved = True
+        for name in row:
+            field = fields_by_name.get(str(name))
+            if field is None:
+                continue
+            template_row_length = _field_template_row_length(
+                field,
+                lengths_by_que_id=template_row_lengths_by_que_id,
+                lengths_by_title=template_row_lengths_by_title,
+            )
+            if template_row_length is not None:
+                expected_template_lengths.append(template_row_length)
+            question, preserved = _materialize_edit_question(field, temp_id=temp_id)
+            questions.append(question)
+            row_preserved = row_preserved and preserved
+            temp_id -= 100
+        if not questions:
+            continue
+        if not row_preserved or _row_needs_width_reflow(expected_template_lengths, len(questions)):
+            _apply_row_widths(questions)
+        form_rows.append(questions)
+
+    for section in layout.get("sections", []) or []:
+        inner_rows: list[list[dict[str, Any]]] = []
+        for row in section.get("rows", []) or []:
+            questions: list[dict[str, Any]] = []
+            expected_template_lengths: list[int] = []
+            row_preserved = True
+            for name in row:
+                field = fields_by_name.get(str(name))
+                if field is None:
+                    continue
+                template_row_length = _field_template_row_length(
+                    field,
+                    lengths_by_que_id=template_row_lengths_by_que_id,
+                    lengths_by_title=template_row_lengths_by_title,
+                )
+                if template_row_length is not None:
+                    expected_template_lengths.append(template_row_length)
+                question, preserved = _materialize_edit_question(field, temp_id=temp_id)
+                questions.append(question)
+                row_preserved = row_preserved and preserved
+                temp_id -= 100
+            if not questions:
+                continue
+            if not row_preserved or _row_needs_width_reflow(expected_template_lengths, len(questions)):
+                _apply_row_widths(questions)
+            inner_rows.append(questions)
+        if not inner_rows:
+            continue
+        template = _select_section_template(section_templates, section)
+        wrapper = deepcopy(template) if isinstance(template, dict) else {
+            "queId": 0,
+            "queTempId": -(20000 + sum(ord(ch) for ch in str(section.get("section_id") or section.get("title") or "section"))),
+            "queType": 24,
+            "queWidth": 100,
+            "scanType": 1,
+            "status": 1,
+            "required": False,
+            "queHint": "",
+            "linkedQuestions": {},
+            "logicalShow": True,
+            "queDefaultValue": None,
+            "queDefaultType": 1,
+            "subQueWidth": 2,
+            "beingHide": False,
+            "beingDesensitized": False,
+        }
+        if section.get("title") is not None:
+            wrapper["queTitle"] = section.get("title") or wrapper.get("queTitle") or "未命名分组"
+        parsed_section_id = _coerce_positive_int(section.get("section_id"))
+        if parsed_section_id is not None:
+            wrapper["sectionId"] = parsed_section_id
+        elif template is None and section.get("section_id") is not None:
+            wrapper["sectionId"] = section.get("section_id")
+        wrapper["innerQuestions"] = inner_rows
+        form_rows.append([wrapper])
+
+    rename_by_que_id, rename_by_title = _field_rename_maps(fields)
+    if rename_by_que_id or rename_by_title:
+        _sync_question_title_references(form_rows, by_que_id=rename_by_que_id, by_title=rename_by_title)
+    normalized_relations = _normalize_question_relations_for_save(
+        question_relations if question_relations is not None else (current_schema.get("questionRelations") or [])
+    )
+    if rename_by_que_id or rename_by_title:
+        _sync_question_title_references(normalized_relations, by_que_id=rename_by_que_id, by_title=rename_by_title)
+
+    payload = _build_form_save_base_payload(current_schema, title)
+    payload["formQues"] = form_rows
+    _normalize_formula_defaults_for_save(payload.get("formQues"))
+    payload["questionRelations"] = normalized_relations
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
-    payload["questionRelations"] = deepcopy(question_relations if question_relations is not None else (current_schema.get("questionRelations") or []))
     return payload
 
 
@@ -13048,6 +14419,8 @@ def _summarize_views(result: Any) -> list[dict[str, Any]]:
         view_type = _normalize_view_type_name(view.get("viewgraphType") or view.get("type"))
         columns = view.get("columnNames") or view.get("columns") or []
         group_by = view.get("groupBy") or view.get("group_by")
+        if not any((name, view_type, columns, group_by)) and str(view_key or "").isdigit():
+            continue
         if not any((name, view_key, view_type, columns, group_by)):
             continue
         items.append(
@@ -13090,11 +14463,24 @@ def _summarize_views_with_config(views_tool: ViewTools, *, profile: str, views:
             enriched_items.append(item)
             continue
         config = config_response.get("result") if isinstance(config_response.get("result"), dict) else {}
-        enriched_items.append(_merge_view_summary_with_config(item, config=config))
+        question_list: list[dict[str, Any]] = []
+        try:
+            question_response = views_tool.view_list_questions(profile=profile, viewgraph_key=view_key)
+            raw_question_list = question_response.get("result")
+            if isinstance(raw_question_list, list):
+                question_list = [deepcopy(entry) for entry in raw_question_list if isinstance(entry, dict)]
+        except (QingflowApiError, RuntimeError):
+            question_list = []
+        enriched_items.append(_merge_view_summary_with_config(item, config=config, question_list=question_list))
     return enriched_items, config_read_errors
 
 
-def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, Any]) -> dict[str, Any]:
+def _merge_view_summary_with_config(
+    base: dict[str, Any],
+    *,
+    config: dict[str, Any],
+    question_list: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
     summary = deepcopy(base)
     if not isinstance(config, dict) or not config:
         return summary
@@ -13102,6 +14488,7 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
         summary["visibility_summary"] = _visibility_summary(_public_visibility_from_member_auth(config.get("auth")))
     legacy_columns = [str(value) for value in (summary.get("columns") or []) if str(value or "").strip()]
     question_entries = _extract_view_question_entries(config.get("viewgraphQuestions"))
+    canonical_question_entries = _extract_view_question_entries(question_list)
     question_entries_by_id = {
         field_id: entry
         for entry in question_entries
@@ -13121,19 +14508,20 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
     display_entries = _sort_view_question_entries(
         [entry for entry in question_entries if bool(entry.get("visible", True))],
     )
+    public_display_entries = _filter_public_view_display_entries(display_entries, configured_column_ids=configured_column_ids)
     display_column_ids = [
         field_id
-        for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in display_entries)
+        for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in public_display_entries)
         if field_id is not None
     ]
     display_columns = [
         str(entry.get("name") or "").strip()
-        for entry in display_entries
+        for entry in public_display_entries
         if str(entry.get("name") or "").strip()
     ]
     apply_entries = [
         entry
-        for entry in display_entries
+        for entry in public_display_entries
         if _coerce_nonnegative_int(entry.get("field_id")) is not None
         and str(entry.get("name") or "").strip()
         and str(entry.get("name") or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
@@ -13180,8 +14568,42 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
         summary["apply_columns"] = apply_columns
         summary["apply_column_ids"] = apply_column_ids
         config_enriched = True
-    if question_entries:
-        summary["column_details"] = display_entries or _sort_view_question_entries(question_entries)
+    if canonical_question_entries:
+        canonical_display_entries = _sort_view_question_entries(canonical_question_entries)
+        canonical_display_column_ids = [
+            field_id
+            for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in canonical_display_entries)
+            if field_id is not None
+        ]
+        canonical_display_columns = [
+            str(entry.get("name") or "").strip()
+            for entry in canonical_display_entries
+            if str(entry.get("name") or "").strip()
+        ]
+        canonical_apply_entries = [
+            entry
+            for entry in canonical_display_entries
+            if _coerce_nonnegative_int(entry.get("field_id")) is not None
+            and str(entry.get("name") or "").strip()
+            and str(entry.get("name") or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
+        ]
+        summary["columns"] = canonical_display_columns
+        summary["display_columns"] = canonical_display_columns
+        summary["display_column_ids"] = canonical_display_column_ids
+        summary["column_details"] = canonical_display_entries
+        summary["apply_columns"] = [
+            str(entry.get("name") or "").strip()
+            for entry in canonical_apply_entries
+            if str(entry.get("name") or "").strip()
+        ]
+        summary["apply_column_ids"] = [
+            field_id
+            for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in canonical_apply_entries)
+            if field_id is not None
+        ]
+        config_enriched = True
+    elif question_entries:
+        summary["column_details"] = public_display_entries or _sort_view_question_entries(question_entries)
         config_enriched = True
     display_config = _extract_view_display_config(
         config,
@@ -13206,7 +14628,7 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
         summary["button_read_source"] = button_source
         config_enriched = True
     if config_enriched:
-        summary["read_source"] = "view_config"
+        summary["read_source"] = "view_config+question" if canonical_question_entries else "view_config"
     return summary
 
 
@@ -13214,29 +14636,64 @@ def _extract_view_question_entries(questions: Any) -> list[dict[str, Any]]:
     if not isinstance(questions, list):
         return []
     entries: list[dict[str, Any]] = []
-    for index, item in enumerate(questions, start=1):
-        if not isinstance(item, dict):
-            continue
-        field_id = _coerce_nonnegative_int(item.get("queId"))
-        name = str(item.get("queTitle") or "").strip() or None
-        visible_raw = item.get("beingListDisplay")
-        if visible_raw is None:
-            visible_raw = item.get("beingVisible")
-        visible = bool(visible_raw) if visible_raw is not None else True
-        display_order = _coerce_positive_int(item.get("displayOrdinal"))
-        entry: dict[str, Any] = {
-            "field_id": field_id,
-            "name": name,
-            "visible": visible,
-            "display_order": display_order if display_order is not None else index,
-        }
-        width = _coerce_positive_int(item.get("width"))
-        if width is not None:
-            entry["width"] = width
-        entries.append(entry)
+    fallback_order = 0
+
+    def walk(nodes: Any) -> None:
+        nonlocal fallback_order
+        if not isinstance(nodes, list):
+            return
+        for item in nodes:
+            if not isinstance(item, dict):
+                continue
+            children: list[Any] = []
+            for child_key in ("innerQues", "subQues", "innerQuestions", "subQuestions"):
+                child_value = item.get(child_key)
+                if isinstance(child_value, list) and child_value:
+                    children.extend(child_value)
+            if children:
+                walk(children)
+                continue
+            field_id = _coerce_nonnegative_int(item.get("queId"))
+            name = str(item.get("queTitle") or "").strip() or None
+            if field_id is None and name is None:
+                continue
+            visible_raw = item.get("beingListDisplay")
+            if visible_raw is None:
+                visible_raw = item.get("beingVisible")
+            visible = bool(visible_raw) if visible_raw is not None else True
+            display_order = _coerce_positive_int(item.get("displayOrdinal"))
+            fallback_order += 1
+            entry: dict[str, Any] = {
+                "field_id": field_id,
+                "name": name,
+                "visible": visible,
+                "display_order": display_order if display_order is not None else fallback_order,
+            }
+            width = _coerce_positive_int(item.get("width"))
+            if width is not None:
+                entry["width"] = width
+            entries.append(entry)
+
+    walk(questions)
     return entries
 
 
+def _filter_public_view_display_entries(
+    entries: list[dict[str, Any]],
+    *,
+    configured_column_ids: list[int],
+) -> list[dict[str, Any]]:
+    configured_set = set(configured_column_ids)
+    filtered: list[dict[str, Any]] = []
+    for entry in entries:
+        name = str(entry.get("name") or "").strip()
+        field_id = _coerce_nonnegative_int(entry.get("field_id"))
+        if name in _KNOWN_SYSTEM_VIEW_COLUMNS and field_id not in configured_set:
+            continue
+        filtered.append(entry)
+    return filtered or entries
+
+
 def _sort_view_question_entries(entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
     return sorted(
         entries,
@@ -14296,9 +15753,10 @@ def _build_form_payload_from_existing_schema(
         wrapper["queWidth"] = 100
         form_rows.append([wrapper])
 
-    payload = deepcopy(current_schema)
+    payload = _build_form_save_base_payload(current_schema, str(current_schema.get("formTitle") or "未命名应用"))
     payload["formQues"] = form_rows
-    payload["questionRelations"] = deepcopy(current_schema.get("questionRelations") or [])
+    _normalize_formula_defaults_for_save(payload.get("formQues"))
+    payload["questionRelations"] = _normalize_question_relations_for_save(current_schema.get("questionRelations") or [])
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
     payload.setdefault("formTitle", current_schema.get("formTitle") or "未命名应用")
     return payload