@josephyan/qingflow-cli 0.2.0-beta.67 → 0.2.0-beta.68

package/src/qingflow_mcp/builder_facade/service.py

@@ -84,6 +84,8 @@ QUESTION_TYPE_TO_FIELD_TYPE: dict[int, str] = {
     11: FieldType.single_select.value,
     12: FieldType.multi_select.value,
     13: FieldType.attachment.value,
+    20: FieldType.q_linker.value,
+    26: FieldType.code_block.value,
     18: FieldType.subtable.value,
     21: FieldType.address.value,
     22: FieldType.department.value,
@@ -104,6 +106,8 @@ FIELD_TYPE_TO_QUESTION_TYPE: dict[str, int] = {
     FieldType.single_select.value: 11,
     FieldType.multi_select.value: 12,
     FieldType.attachment.value: 13,
+    FieldType.q_linker.value: 20,
+    FieldType.code_block.value: 26,
     FieldType.subtable.value: 18,
     FieldType.address.value: 21,
     FieldType.department.value: 22,
@@ -118,6 +122,9 @@ JUDGE_LESS_OR_EQUAL = 7
 JUDGE_EQUAL_ANY = 9
 JUDGE_FUZZY_MATCH = 19
 JUDGE_INCLUDE_ANY = 20
+DEFAULT_TYPE_RELATION = 2
+RELATION_TYPE_Q_LINKER = 2
+RELATION_TYPE_CODE_BLOCK = 3
 
 INCLUDE_ANY_FLOW_FIELD_TYPES = {
     FieldType.multi_select.value,
@@ -144,6 +151,13 @@ class PermissionCheckOutcome:
     verification: JSONObject = field(default_factory=dict)
 
 
+@dataclass(slots=True)
+class RelationHydrationResult:
+    fields: list[dict[str, Any]]
+    permission_outcome: PermissionCheckOutcome | None = None
+    degraded_expectations: list[dict[str, Any]] = field(default_factory=list)
+
+
 class AiBuilderFacade:
     def __init__(
         self,
@@ -2088,7 +2102,7 @@ class AiBuilderFacade:
         layout = parsed["layout"]
         response = AppLayoutReadResponse(
             app_key=app_key,
-            sections=layout.get("sections", []),
+            sections=_decorate_layout_sections_as_paragraphs(layout.get("sections", [])),
             unplaced_fields=_find_unplaced_fields(parsed["fields"], layout),
             layout_mode_detected=_detect_layout_mode(layout),
         )
@@ -2390,7 +2404,7 @@ class AiBuilderFacade:
         current_layout = self.app_read_layout_summary(profile=profile, app_key=request.app_key)
         if current_layout.get("status") == "failed":
             return current_layout
-        requested_sections = [section.model_dump(mode="json") for section in request.sections]
+        requested_sections = [section.model_dump(mode="json", exclude_none=True) for section in request.sections]
         if request.preset is not None:
             requested_sections = _build_layout_preset_sections(preset=request.preset, field_names=current_names)
         else:
@@ -2960,8 +2974,15 @@ class AiBuilderFacade:
             removed.append(field["name"])
             selector_map = _build_selector_map(current_fields)
 
+        relation_permission_outcome: PermissionCheckOutcome | None = None
+        relation_degraded_expectations: list[dict[str, Any]] = []
+        relation_target_metadata_verified = True
         try:
-            current_fields = _hydrate_relation_field_configs(self, profile=profile, fields=current_fields)
+            relation_hydration = _hydrate_relation_field_configs(self, profile=profile, fields=current_fields)
+            current_fields = relation_hydration.fields
+            relation_permission_outcome = relation_hydration.permission_outcome
+            relation_degraded_expectations = relation_hydration.degraded_expectations
+            relation_target_metadata_verified = not bool(relation_degraded_expectations)
         except (QingflowApiError, RuntimeError) as error:
             api_error = _coerce_api_error(error)
             return _failed_from_api_error(
@@ -2980,6 +3001,36 @@ class AiBuilderFacade:
                 suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
             )
 
+        try:
+            current_fields, compiled_question_relations = _compile_code_block_binding_fields(
+                fields=current_fields,
+                current_schema=schema_result,
+            )
+        except ValueError as error:
+            return _failed(
+                "CODE_BLOCK_BINDING_INVALID",
+                str(error),
+                normalized_args=normalized_args,
+                details={"app_key": target.app_key},
+                suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+            )
+
+        q_linker_schema_context = deepcopy(schema_result)
+        q_linker_schema_context["questionRelations"] = deepcopy(compiled_question_relations)
+        try:
+            current_fields, compiled_question_relations = _compile_q_linker_binding_fields(
+                fields=current_fields,
+                current_schema=q_linker_schema_context,
+            )
+        except ValueError as error:
+            return _failed(
+                "Q_LINKER_BINDING_INVALID",
+                str(error),
+                normalized_args=normalized_args,
+                details={"app_key": target.app_key},
+                suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+            )
+
         relation_field_count = _count_relation_fields(current_fields)
         relation_limit_verified = relation_field_count <= 1
         relation_warnings = (
@@ -3008,6 +3059,7 @@ class AiBuilderFacade:
                     "fields_verified": True,
                     "relation_field_limit_verified": relation_limit_verified,
                     "app_visuals_verified": True,
+                    "relation_target_metadata_verified": relation_target_metadata_verified,
                 },
                 "app_key": target.app_key,
                 "app_icon": str(visual_result.get("app_icon") or "").strip() or None,
@@ -3018,6 +3070,7 @@ class AiBuilderFacade:
                 "package_attached": package_attached,
             }
             response["details"]["relation_field_count"] = relation_field_count
+            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(
@@ -3025,6 +3078,7 @@ class AiBuilderFacade:
             current_schema=schema_result,
             fields=current_fields,
             layout=layout,
+            question_relations=compiled_question_relations,
         )
         payload["editVersionNo"] = self._resolve_form_edit_version(
             profile=profile,
@@ -3066,6 +3120,81 @@ class AiBuilderFacade:
                 },
                 suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
             )
+        if _code_block_relations_need_source_rebind(compiled_question_relations) or _q_linker_relations_need_source_rebind(compiled_question_relations):
+            try:
+                rebound_schema = self.apps.app_get_form_schema(
+                    profile=profile,
+                    app_key=target.app_key,
+                    form_type=1,
+                    being_draft=True,
+                    being_apply=None,
+                    audit_node_id=None,
+                    include_raw=True,
+                ).get("result") or {}
+                rebound_parsed = _parse_schema(rebound_schema)
+                rebound_fields = cast(list[dict[str, Any]], rebound_parsed.get("fields") or [])
+                rebound_layout = cast(dict[str, Any], rebound_parsed.get("layout") or {"root_rows": [], "sections": []})
+                _overlay_code_block_binding_fields(target_fields=rebound_fields, source_fields=current_fields)
+                _overlay_q_linker_binding_fields(target_fields=rebound_fields, source_fields=current_fields)
+                rebound_fields, compiled_question_relations = _compile_code_block_binding_fields(
+                    fields=rebound_fields,
+                    current_schema=rebound_schema,
+                )
+                rebound_q_linker_schema = deepcopy(rebound_schema)
+                rebound_q_linker_schema["questionRelations"] = deepcopy(compiled_question_relations)
+                rebound_fields, compiled_question_relations = _compile_q_linker_binding_fields(
+                    fields=rebound_fields,
+                    current_schema=rebound_q_linker_schema,
+                )
+            except ValueError as error:
+                return _failed(
+                    "Q_LINKER_BINDING_INVALID" if "q_linker" in str(error) else "CODE_BLOCK_BINDING_INVALID",
+                    str(error),
+                    normalized_args=normalized_args,
+                    details={"app_key": target.app_key},
+                    suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+                )
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                return _failed_from_api_error(
+                    "SCHEMA_APPLY_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    allowed_values={"field_types": [item.value for item in PublicFieldType]},
+                    details={
+                        "app_key": target.app_key,
+                        "field_diff": {"added": added, "updated": updated, "removed": removed},
+                    },
+                    suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+                )
+            rebound_payload = _build_form_payload_from_fields(
+                title=rebound_schema.get("formTitle") or target.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,
+                app_key=target.app_key,
+                current_schema=rebound_schema,
+            )
+            try:
+                self.apps.app_update_form_schema(profile=profile, app_key=target.app_key, payload=rebound_payload)
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                return _failed_from_api_error(
+                    "SCHEMA_APPLY_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    allowed_values={"field_types": [item.value for item in PublicFieldType]},
+                    details={
+                        "app_key": target.app_key,
+                        "field_diff": {"added": added, "updated": updated, "removed": removed},
+                    },
+                    suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
+                )
+            current_fields = rebound_fields
         response = {
             "status": "success",
             "error_code": None,
@@ -3084,6 +3213,7 @@ class AiBuilderFacade:
                 "package_attached": None,
                 "app_visuals_verified": True,
                 "relation_field_limit_verified": relation_limit_verified,
+                "relation_target_metadata_verified": relation_target_metadata_verified,
             },
             "app_key": target.app_key,
             "app_icon": str(visual_result.get("app_icon") or resolved.get("app_icon") or "").strip() or None,
@@ -3100,6 +3230,7 @@ class AiBuilderFacade:
         response["details"]["relation_field_count"] = relation_field_count
         if schema_readback_delayed:
             response["verification"]["schema_readback_delayed"] = True
+        response = _apply_permission_outcomes(response, relation_permission_outcome)
         response = self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response)
         verification_ok = False
         tag_ids_after: list[int] = []
@@ -3109,6 +3240,19 @@ class AiBuilderFacade:
             verified = self.app_read(profile=profile, app_key=target.app_key, include_raw=False)
             verified_field_names = {field["name"] for field in verified["schema"]["fields"]}
             verification_ok = all(name in verified_field_names for name in added + updated) and all(name not in verified_field_names for name in removed)
+            if relation_degraded_expectations:
+                relation_verified_fields = cast(list[dict[str, Any]], verified["schema"]["fields"])
+                try:
+                    relation_readback = self.app_read_fields(profile=profile, app_key=target.app_key)
+                    relation_verified_fields = cast(list[dict[str, Any]], relation_readback.get("fields") or relation_verified_fields)
+                except (QingflowApiError, RuntimeError):
+                    relation_verified_fields = cast(list[dict[str, Any]], verified["schema"]["fields"])
+                relation_readback_verified = _verify_relation_readback_by_name(
+                    verified_fields=relation_verified_fields,
+                    degraded_expectations=relation_degraded_expectations,
+                )
+                response["verification"]["relation_target_readback_by_name_verified"] = relation_readback_verified
+                verification_ok = verification_ok and relation_readback_verified
         except (QingflowApiError, RuntimeError) as error:
             verification_error = _coerce_api_error(error)
             verification_ok = False
@@ -3170,7 +3314,7 @@ class AiBuilderFacade:
         sections: list[LayoutSectionPatch],
         publish: bool = True,
     ) -> JSONObject:
-        requested_sections = [section.model_dump(mode="json") for section in sections]
+        requested_sections = [section.model_dump(mode="json", exclude_none=True) for section in sections]
         normalized_args = {
             "app_key": app_key,
             "mode": mode.value,
@@ -6415,6 +6559,21 @@ def _coerce_nonnegative_int(value: Any) -> int | None:
     return None
 
 
+def _coerce_any_int(value: Any) -> int | None:
+    if isinstance(value, bool) or value is None:
+        return None
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return int(value)
+    if isinstance(value, str) and value.strip():
+        try:
+            return int(value)
+        except ValueError:
+            return None
+    return None
+
+
 def _coerce_int_list(values: Any) -> list[int]:
     if not isinstance(values, list):
         return []
@@ -7274,14 +7433,159 @@ def _normalize_relation_mode(value: Any) -> str:
     return _relation_mode_from_optional_data_num(value)
 
 
+def _is_relation_target_metadata_read_restricted_api_error(error: QingflowApiError) -> bool:
+    return error.backend_code in {40002, 40027, 40161}
+
+
+def _relation_target_field_matches(left: dict[str, Any], right: dict[str, Any]) -> bool:
+    left_field_id = str(left.get("field_id") or "").strip()
+    right_field_id = str(right.get("field_id") or "").strip()
+    left_que_id = _coerce_positive_int(left.get("que_id"))
+    right_que_id = _coerce_positive_int(right.get("que_id"))
+    left_name = str(left.get("name") or "").strip()
+    right_name = str(right.get("name") or "").strip()
+    return (
+        (left_field_id and right_field_id and left_field_id == right_field_id)
+        or (left_que_id is not None and right_que_id is not None and left_que_id == right_que_id)
+        or (left_name and right_name and left_name == right_name)
+    )
+
+
+def _normalize_relation_target_stub(
+    selector_payload: dict[str, Any] | None,
+    *,
+    fallback_name: str | None = None,
+) -> dict[str, Any]:
+    payload = selector_payload if isinstance(selector_payload, dict) else {}
+    name = str(payload.get("name") or fallback_name or "").strip() or None
+    if name is None:
+        raise ValueError("relation target selector requires a field name when target app metadata cannot be read")
+    return {
+        "field_id": str(payload.get("field_id") or "").strip() or None,
+        "que_id": 0,
+        "name": name,
+        "type": str(payload.get("type") or "").strip() or None,
+    }
+
+
+def _apply_relation_target_selection(
+    *,
+    field: dict[str, Any],
+    config: dict[str, Any],
+    display_field: dict[str, Any],
+    visible_fields: list[dict[str, Any]],
+) -> None:
+    normalized_visible = [deepcopy(item) for item in visible_fields if isinstance(item, dict)]
+    if not normalized_visible:
+        normalized_visible = [deepcopy(display_field)]
+    elif not any(_relation_target_field_matches(item, display_field) for item in normalized_visible):
+        normalized_visible = [deepcopy(display_field), *normalized_visible]
+    config["target_field_label"] = display_field.get("name")
+    config["target_field_type"] = display_field.get("type")
+    config["target_field_que_id"] = _coerce_positive_int(display_field.get("que_id")) or 0
+    config["refer_field_ids"] = [item.get("field_id") or item.get("name") for item in normalized_visible]
+    config["refer_field_que_ids"] = [_coerce_positive_int(item.get("que_id")) or 0 for item in normalized_visible]
+    config["refer_field_labels"] = [item.get("name") for item in normalized_visible]
+    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["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
+    field["config"] = config
+    field["display_field"] = {
+        "field_id": display_field.get("field_id"),
+        "que_id": _coerce_positive_int(display_field.get("que_id")) or 0,
+        "name": display_field.get("name"),
+    }
+    field["visible_fields"] = [
+        {
+            "field_id": item.get("field_id"),
+            "que_id": _coerce_positive_int(item.get("que_id")) or 0,
+            "name": item.get("name"),
+        }
+        for item in normalized_visible
+    ]
+
+
+def _verify_relation_readback_by_name(
+    *,
+    verified_fields: list[dict[str, Any]],
+    degraded_expectations: list[dict[str, Any]],
+) -> bool:
+    if not degraded_expectations:
+        return True
+    verified_by_name = {
+        str(field.get("name") or "").strip(): field
+        for field in verified_fields
+        if isinstance(field, dict) and str(field.get("name") or "").strip()
+    }
+    for expectation in degraded_expectations:
+        field_name = str(expectation.get("field_name") or "").strip()
+        actual = verified_by_name.get(field_name)
+        if not isinstance(actual, dict):
+            return False
+        if str(actual.get("type") or "") != FieldType.relation.value:
+            return False
+        if str(actual.get("target_app_key") or "") != str(expectation.get("target_app_key") or ""):
+            return False
+        if _normalize_relation_mode(actual.get("relation_mode")) != _normalize_relation_mode(expectation.get("relation_mode")):
+            return False
+        expected_display_name = str((expectation.get("display_field") or {}).get("name") or "").strip()
+        actual_display_name = str((actual.get("display_field") or {}).get("name") or "").strip()
+        if expected_display_name != actual_display_name:
+            return False
+        expected_visible_names = [
+            str(item.get("name") or "").strip()
+            for item in cast(list[Any], expectation.get("visible_fields") or [])
+            if isinstance(item, dict) and str(item.get("name") or "").strip()
+        ]
+        actual_visible_names = [
+            str(item.get("name") or "").strip()
+            for item in cast(list[Any], actual.get("visible_fields") or [])
+            if isinstance(item, dict) and str(item.get("name") or "").strip()
+        ]
+        if expected_visible_names != actual_visible_names:
+            return False
+    return True
+
+
+def _relation_target_metadata_skip_outcome(*, degraded_entries: list[dict[str, Any]]) -> PermissionCheckOutcome | None:
+    if not degraded_entries:
+        return None
+    first = degraded_entries[0]
+    transport_error = first.get("transport_error") if isinstance(first.get("transport_error"), dict) else None
+    outcome = _permission_skip_outcome(
+        scope="relation_target_metadata",
+        target={
+            "app_key": first.get("target_app_key"),
+            "field_name": first.get("field_name"),
+        },
+        required_permission="read_schema",
+        transport_error=deepcopy(transport_error) if transport_error is not None else None,
+    )
+    outcome.details["relation_target_metadata_unverified"] = True
+    outcome.verification["relation_target_metadata_verified"] = False
+    outcome.warnings.append(
+        _warning(
+            "RELATION_TARGET_METADATA_UNVERIFIED",
+            "relation target metadata could not be verified before schema apply; writing using explicit field names",
+            field_name=first.get("field_name"),
+            target_app_key=first.get("target_app_key"),
+        )
+    )
+    return outcome
+
+
 def _hydrate_relation_field_configs(
     facade: "AiBuilderFacade",
     *,
     profile: str,
     fields: list[dict[str, Any]],
-) -> list[dict[str, Any]]:
+) -> RelationHydrationResult:
     resolved_fields = deepcopy(fields)
     target_field_cache: dict[str, list[dict[str, Any]]] = {}
+    degraded_entries: list[dict[str, Any]] = []
     for field in resolved_fields:
         if not isinstance(field, dict) or field.get("type") != FieldType.relation.value:
             continue
@@ -7299,9 +7603,39 @@ def _hydrate_relation_field_configs(
             continue
         target_fields = target_field_cache.get(target_app_key)
         if target_fields is None:
-            target_schema, _ = facade._read_schema_with_fallback(profile=profile, app_key=target_app_key)
-            target_fields = _parse_schema(target_schema)["fields"]
-            target_field_cache[target_app_key] = target_fields
+            try:
+                target_schema, _ = facade._read_schema_with_fallback(profile=profile, app_key=target_app_key)
+                target_fields = _parse_schema(target_schema)["fields"]
+                target_field_cache[target_app_key] = target_fields
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                if not _is_relation_target_metadata_read_restricted_api_error(api_error):
+                    raise
+                display_field = _normalize_relation_target_stub(
+                    display_selector,
+                    fallback_name=str((display_selector or {}).get("name") or "").strip() or None,
+                )
+                visible_fields = [
+                    _normalize_relation_target_stub(item, fallback_name=str(item.get("name") or "").strip() or None)
+                    for item in visible_selector_payloads
+                ]
+                _apply_relation_target_selection(
+                    field=field,
+                    config=config,
+                    display_field=display_field,
+                    visible_fields=visible_fields,
+                )
+                degraded_entries.append(
+                    {
+                        "field_name": field.get("name"),
+                        "target_app_key": target_app_key,
+                        "display_field": deepcopy(field.get("display_field") or {}),
+                        "visible_fields": deepcopy(field.get("visible_fields") or []),
+                        "relation_mode": field.get("relation_mode"),
+                        "transport_error": _transport_error_payload(api_error),
+                    }
+                )
+                continue
         if not target_fields:
             raise ValueError(f"target relation app '{target_app_key}' has no readable fields")
         display_field = _resolve_relation_target_field(
@@ -7313,41 +7647,17 @@ def _hydrate_relation_field_configs(
             _resolve_relation_target_field(target_fields=target_fields, selector_payload=item)
             for item in visible_selector_payloads
         ]
-        if not visible_fields:
-            visible_fields = [display_field]
-        elif not any(
-            str(item.get("field_id") or "") == str(display_field.get("field_id") or "")
-            or _coerce_positive_int(item.get("que_id")) == _coerce_positive_int(display_field.get("que_id"))
-            for item in visible_fields
-        ):
-            visible_fields = [display_field, *visible_fields]
-        config["target_field_label"] = display_field.get("name")
-        config["target_field_type"] = display_field.get("type")
-        config["target_field_que_id"] = display_field.get("que_id")
-        config["refer_field_ids"] = [item.get("field_id") for item in visible_fields]
-        config["refer_field_que_ids"] = [item.get("que_id") or 0 for item in visible_fields]
-        config["refer_field_labels"] = [item.get("name") for item in visible_fields]
-        config["refer_field_types"] = [item.get("type") for item in visible_fields]
-        config["auth_field_ids"] = [item.get("field_id") for item in visible_fields]
-        config["auth_field_que_ids"] = [item.get("que_id") or 0 for item in visible_fields]
-        config["field_name_show"] = bool(field.get("field_name_show", True))
-        field["target_field_id"] = display_field.get("field_id")
-        field["target_field_que_id"] = display_field.get("que_id")
-        field["config"] = config
-        field["display_field"] = {
-            "field_id": display_field.get("field_id"),
-            "que_id": display_field.get("que_id"),
-            "name": display_field.get("name"),
-        }
-        field["visible_fields"] = [
-            {
-                "field_id": item.get("field_id"),
-                "que_id": item.get("que_id"),
-                "name": item.get("name"),
-            }
-            for item in visible_fields
-        ]
-    return resolved_fields
+        _apply_relation_target_selection(
+            field=field,
+            config=config,
+            display_field=display_field,
+            visible_fields=visible_fields,
+        )
+    return RelationHydrationResult(
+        fields=resolved_fields,
+        permission_outcome=_relation_target_metadata_skip_outcome(degraded_entries=degraded_entries),
+        degraded_expectations=degraded_entries,
+    )
 
 
 def _slugify(text: str, *, default: str) -> str:
@@ -7380,9 +7690,12 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         "options": [],
         "option_details": [],
         "target_app_key": None,
+        "config": {},
         "subfields": [],
         "que_id": que_id,
         "que_type": que_type,
+        "default_type": _coerce_positive_int(question.get("queDefaultType")) or 1,
+        "default_value": question.get("queDefaultValue"),
     }
     if field_type in {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value}:
         options = question.get("options")
@@ -7429,6 +7742,61 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         }
         field["visible_fields"] = visible_fields
         field["field_name_show"] = bool(reference.get("fieldNameShow", True))
+    if field_type == FieldType.code_block:
+        code_block_config = question.get("codeBlockConfig") if isinstance(question.get("codeBlockConfig"), dict) else {}
+        field["code_block_config"] = {
+            "config_mode": _coerce_positive_int(code_block_config.get("configMode")) or 1,
+            "code_content": str(code_block_config.get("codeContent") or ""),
+            "being_hide_on_form": bool(code_block_config.get("beingHideOnForm", False)),
+            "result_alias_path": [
+                item
+                for item in (
+                    _normalize_code_block_alias_path_item(alias)
+                    for alias in cast(list[Any], code_block_config.get("resultAliasPath") or [])
+                )
+                if item is not None
+            ],
+        }
+        field["config"] = deepcopy(field["code_block_config"])
+        if question.get("autoTrigger") is not None:
+            field["auto_trigger"] = bool(question.get("autoTrigger"))
+        if question.get("customBtnTextStatus") is not None:
+            field["custom_button_text_enabled"] = bool(question.get("customBtnTextStatus"))
+        if question.get("customBtnText") is not None:
+            field["custom_button_text"] = str(question.get("customBtnText") or "")
+    if field_type == FieldType.q_linker:
+        remote_lookup_config = _normalize_remote_lookup_config(question.get("remoteLookupConfig") or {}) or {
+            "config_mode": 1,
+            "url": "",
+            "method": "GET",
+            "headers": [],
+            "body_type": 1,
+            "url_encoded_value": [],
+            "json_value": None,
+            "xml_value": None,
+            "result_type": 1,
+            "result_format_path": [],
+            "query_params": [],
+            "auto_trigger": None,
+            "custom_button_text_enabled": None,
+            "custom_button_text": None,
+            "being_insert_value_directly": None,
+            "being_hide_on_form": None,
+        }
+        if question.get("autoTrigger") is not None:
+            remote_lookup_config["auto_trigger"] = bool(question.get("autoTrigger"))
+        if question.get("customBtnTextStatus") is not None:
+            remote_lookup_config["custom_button_text_enabled"] = bool(question.get("customBtnTextStatus"))
+        if question.get("customBtnText") is not None:
+            remote_lookup_config["custom_button_text"] = str(question.get("customBtnText") or "")
+        field["remote_lookup_config"] = remote_lookup_config
+        field["config"] = deepcopy(remote_lookup_config)
+        if remote_lookup_config.get("auto_trigger") is not None:
+            field["auto_trigger"] = bool(remote_lookup_config.get("auto_trigger"))
+        if remote_lookup_config.get("custom_button_text_enabled") is not None:
+            field["custom_button_text_enabled"] = bool(remote_lookup_config.get("custom_button_text_enabled"))
+        if remote_lookup_config.get("custom_button_text") is not None:
+            field["custom_button_text"] = str(remote_lookup_config.get("custom_button_text") or "")
     if field_type == FieldType.subtable:
         subfields = []
         for sub_question in question.get("subQuestions", []) or []:
@@ -7462,9 +7830,12 @@ def _parse_schema(schema: dict[str, Any]) -> dict[str, Any]:
                 if labels:
                     section_rows.append(labels)
             if section_rows:
+                parsed_section_id = _coerce_positive_int(section_question.get("queId"))
+                if parsed_section_id is None:
+                    parsed_section_id = _coerce_positive_int(section_question.get("sectionId"))
                 sections.append(
                     {
-                        "section_id": str(section_question.get("sectionId") or _slugify(section_question.get("queTitle") or "section", default="section")),
+                        "section_id": str(parsed_section_id or _slugify(section_question.get("queTitle") or "section", default="section")),
                         "title": section_question.get("queTitle") or "未命名分组",
                         "rows": section_rows,
                     }
@@ -7480,7 +7851,10 @@ def _parse_schema(schema: dict[str, Any]) -> dict[str, Any]:
         if labels:
             root_rows.append(labels)
     fields = list(fields_by_name.values())
-    return {"fields": fields, "layout": {"root_rows": root_rows, "sections": sections}}
+    parsed = {"fields": fields, "layout": {"root_rows": root_rows, "sections": sections}}
+    _attach_q_linker_binding_readback(parsed=parsed, raw_schema=schema)
+    _attach_code_block_binding_readback(parsed=parsed, raw_schema=schema)
+    return parsed
 
 
 def _resolve_layout_sections_to_names(
@@ -7516,8 +7890,11 @@ def _resolve_layout_sections_to_names(
                 normalized_row.append(resolved_name)
             if normalized_row:
                 normalized_rows.append(normalized_row)
-        normalized_section = deepcopy(section)
-        normalized_section["rows"] = normalized_rows
+        normalized_section = {
+            "section_id": section.get("section_id"),
+            "title": section.get("title"),
+            "rows": normalized_rows,
+        }
         normalized_sections.append(normalized_section)
     return normalized_sections, missing_selectors
 
@@ -7556,96 +7933,554 @@ def _resolve_layout_field_name(
     return None
 
 
-def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any]) -> 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 "")),
-    }
-    if field.get("type") == FieldType.relation.value:
-        payload["target_app_key"] = field.get("target_app_key")
-        payload["relation_mode"] = _normalize_relation_mode(field.get("relation_mode"))
-        payload["display_field"] = deepcopy(field.get("display_field"))
-        payload["visible_fields"] = deepcopy(field.get("visible_fields") or [])
-    return payload
+_CODE_BLOCK_INPUT_LINE_RE = re.compile(
+    r"^\s*const\s+(?P<var>[A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*qf_field\.\{(?P<field>.+?)\$\$[A-Z0-9-]+\$\$\};?\s*$"
+)
 
 
-def _build_selector_map(fields: list[dict[str, Any]]) -> dict[str, int]:
-    mapping: dict[str, int] = {}
-    for index, field in enumerate(fields):
-        field_id = str(field.get("field_id") or "")
-        field_name = str(field.get("name") or "")
+def _attach_code_block_binding_readback(*, parsed: dict[str, Any], raw_schema: dict[str, Any]) -> None:
+    fields = parsed.get("fields") if isinstance(parsed.get("fields"), list) else []
+    if not fields:
+        return
+    by_que_id = {
+        _coerce_positive_int(field.get("que_id")): field
+        for field in fields
+        if isinstance(field, dict) and _coerce_positive_int(field.get("que_id")) is not None
+    }
+    relations = raw_schema.get("questionRelations") if isinstance(raw_schema.get("questionRelations"), list) else []
+    relation_by_source: dict[int, list[dict[str, Any]]] = {}
+    for relation in relations:
+        if not isinstance(relation, dict) or _coerce_positive_int(relation.get("relationType")) != RELATION_TYPE_CODE_BLOCK:
+            continue
+        alias_config = relation.get("aliasConfig") if isinstance(relation.get("aliasConfig"), dict) else {}
+        source_que_id = _coerce_positive_int(alias_config.get("queId"))
+        target_que_id = _coerce_positive_int(relation.get("queId"))
+        alias_name = str(alias_config.get("qlinkerAlias") or relation.get("qlinkerAlias") or "").strip()
+        if source_que_id is None or target_que_id is None or not alias_name:
+            continue
+        relation_by_source.setdefault(source_que_id, []).append(
+            {
+                "alias": alias_name,
+                "alias_id": _coerce_positive_int(alias_config.get("aliasId")),
+                "target_que_id": target_que_id,
+            }
+        )
+    for field in fields:
+        if not isinstance(field, dict) or field.get("type") != FieldType.code_block.value:
+            continue
+        code_block_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or {}
+        alias_paths = cast(list[dict[str, Any]], code_block_config.get("result_alias_path") or [])
         que_id = _coerce_positive_int(field.get("que_id"))
-        if field_id:
-            mapping[f"field_id:{field_id}"] = index
-        if field_name:
-            mapping[f"name:{field_name}"] = index
-        if que_id is not None:
-            mapping[f"que_id:{que_id}"] = index
-    return mapping
+        relation_items = relation_by_source.get(que_id or -1, [])
+        relation_by_alias = {str(item.get("alias") or ""): item for item in relation_items if str(item.get("alias") or "")}
+        inputs, code = _parse_code_block_inputs_and_body(str(code_block_config.get("code_content") or ""))
+        outputs: list[dict[str, Any]] = []
+        metadata_unverified = False
+        for alias_item in alias_paths:
+            alias_name = str(alias_item.get("alias_name") or "").strip()
+            if not alias_name:
+                continue
+            output_payload: dict[str, Any] = {
+                "alias": alias_name,
+                "path": str(alias_item.get("alias_path") or ""),
+                "alias_id": _coerce_positive_int(alias_item.get("alias_id", alias_item.get("aliasId"))),
+            }
+            relation_item = relation_by_alias.get(alias_name)
+            if relation_item is not None:
+                target_field = by_que_id.get(_coerce_positive_int(relation_item.get("target_que_id")))
+                if isinstance(target_field, dict):
+                    output_payload["target_field"] = {
+                        "field_id": target_field.get("field_id"),
+                        "que_id": target_field.get("que_id"),
+                        "name": target_field.get("name"),
+                    }
+                else:
+                    metadata_unverified = True
+            outputs.append(output_payload)
+        for alias_name in relation_by_alias:
+            if any(str(item.get("alias") or "") == alias_name for item in outputs):
+                continue
+            metadata_unverified = True
+        field["code_block_binding"] = {
+            "inputs": inputs,
+            "code": code,
+            "auto_trigger": field.get("auto_trigger"),
+            "custom_button_text_enabled": field.get("custom_button_text_enabled"),
+            "custom_button_text": field.get("custom_button_text"),
+            "outputs": outputs,
+        }
+        if metadata_unverified:
+            field["metadata_unverified"] = True
 
 
-def _resolve_selector(selector_map: dict[str, int], selector: FieldSelector) -> int | None:
-    if selector.field_id:
-        value = selector_map.get(f"field_id:{selector.field_id}")
-        if value is not None:
-            return value
-    if selector.que_id:
-        value = selector_map.get(f"que_id:{selector.que_id}")
-        if value is not None:
-            return value
-    if selector.name:
-        value = selector_map.get(f"name:{selector.name}")
-        if value is not None:
-            return value
-    return None
+def _normalize_q_linker_key_value_item(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    key = str(value.get("key") or "").strip()
+    if not key:
+        return None
+    item_type = _coerce_positive_int(value.get("type")) or 1
+    normalized: dict[str, Any] = {
+        "key": key,
+        "value": None if value.get("value") is None else str(value.get("value") or ""),
+        "type": item_type,
+    }
+    return normalized
 
 
-def _resolve_remove_selector(fields: list[dict[str, Any]], patch: FieldRemovePatch) -> int | None:
-    selector = FieldSelector(field_id=patch.field_id, que_id=patch.que_id, name=patch.name)
-    return _resolve_selector(_build_selector_map(fields), selector)
+def _normalize_q_linker_alias_path_item(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    alias_name = str(value.get("alias_name", value.get("aliasName", "")) or "").strip()
+    alias_path = str(value.get("alias_path", value.get("aliasPath", "")) or "").strip()
+    if not alias_name or not alias_path:
+        return None
+    return {
+        "alias_name": alias_name,
+        "alias_path": alias_path,
+        "alias_id": _coerce_positive_int(value.get("alias_id", value.get("aliasId"))),
+    }
 
 
-def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
-    field_id = _slugify(patch.name, default=f"field_{uuid4().hex[:8]}")
+def _normalize_remote_lookup_config(value: Any) -> dict[str, Any] | None:
+    if value is None or not isinstance(value, dict):
+        return None
+    headers = [
+        item for item in (_normalize_q_linker_key_value_item(raw) for raw in cast(list[Any], value.get("headers") or [])) if item is not None
+    ] if isinstance(value.get("headers"), list) else []
+    query_params = [
+        item for item in (_normalize_q_linker_key_value_item(raw) for raw in cast(list[Any], value.get("query_params", value.get("queryParams")) or [])) if item is not None
+    ] if isinstance(value.get("query_params", value.get("queryParams")), list) else []
+    url_encoded_value = [
+        item for item in (_normalize_q_linker_key_value_item(raw) for raw in cast(list[Any], value.get("url_encoded_value", value.get("urlEncodedValue")) or [])) if item is not None
+    ] if isinstance(value.get("url_encoded_value", value.get("urlEncodedValue")), list) else []
+    result_format_path = [
+        item for item in (_normalize_q_linker_alias_path_item(raw) for raw in cast(list[Any], value.get("result_format_path", value.get("resultFormatPath")) or [])) if item is not None
+    ] if isinstance(value.get("result_format_path", value.get("resultFormatPath")), list) else []
     return {
-        "field_id": field_id,
-        "name": patch.name,
-        "type": patch.type.value,
-        "required": patch.required,
-        "description": patch.description,
-        "options": list(patch.options),
-        "target_app_key": patch.target_app_key,
-        "display_field": patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None,
-        "visible_fields": [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields],
-        "relation_mode": patch.relation_mode.value if patch.relation_mode is not None else None,
-        "subfields": [_field_patch_to_internal(subfield) for subfield in patch.subfields],
-        "que_id": None,
+        "config_mode": _coerce_positive_int(value.get("config_mode", value.get("configMode"))) or 1,
+        "url": str(value.get("url") or ""),
+        "method": str(value.get("method") or "GET").upper() or "GET",
+        "headers": headers,
+        "body_type": _coerce_positive_int(value.get("body_type", value.get("bodyType"))) or 1,
+        "url_encoded_value": url_encoded_value,
+        "json_value": None if value.get("json_value", value.get("jsonValue")) is None else str(value.get("json_value", value.get("jsonValue")) or ""),
+        "xml_value": None if value.get("xml_value", value.get("xmlValue")) is None else str(value.get("xml_value", value.get("xmlValue")) or ""),
+        "result_type": _coerce_positive_int(value.get("result_type", value.get("resultType"))) or 1,
+        "result_format_path": result_format_path,
+        "query_params": query_params,
+        "auto_trigger": None if value.get("auto_trigger", value.get("autoTrigger")) is None else bool(value.get("auto_trigger", value.get("autoTrigger"))),
+        "custom_button_text_enabled": None if value.get("custom_button_text_enabled", value.get("customButtonTextEnabled", value.get("custom_btn_text_status", value.get("customBtnTextStatus")))) is None else bool(value.get("custom_button_text_enabled", value.get("customButtonTextEnabled", value.get("custom_btn_text_status", value.get("customBtnTextStatus"))))),
+        "custom_button_text": None if value.get("custom_button_text", value.get("customButtonText", value.get("custom_btn_text", value.get("customBtnText")))) is None else str(value.get("custom_button_text", value.get("customButtonText", value.get("custom_btn_text", value.get("customBtnText")))) or ""),
+        "being_insert_value_directly": None if value.get("being_insert_value_directly", value.get("beingInsertValueDirectly")) is None else bool(value.get("being_insert_value_directly", value.get("beingInsertValueDirectly"))),
+        "being_hide_on_form": None if value.get("being_hide_on_form", value.get("beingHideOnForm")) is None else bool(value.get("being_hide_on_form", value.get("beingHideOnForm"))),
     }
 
 
-def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
-    return (
-        str(field.get("name") or "") == patch.name
-        and str(field.get("type") or "") == patch.type.value
-        and bool(field.get("required")) == patch.required
-        and (field.get("description") or None) == patch.description
-        and list(field.get("options") or []) == list(patch.options)
-        and (field.get("target_app_key") or None) == patch.target_app_key
-        and _field_selector_payload_equal(field.get("display_field"), patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None)
-        and _field_selector_list_equal(field.get("visible_fields"), [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields])
-        and _normalize_relation_mode(field.get("relation_mode")) == _normalize_relation_mode(patch.relation_mode.value if patch.relation_mode is not None else None)
-        and len(field.get("subfields") or []) == len(patch.subfields)
-    )
+def _serialize_remote_lookup_key_value_item(value: Any) -> dict[str, Any]:
+    normalized = _normalize_q_linker_key_value_item(value) or {"key": "", "value": "", "type": 1}
+    return {
+        "key": normalized["key"],
+        "value": normalized["value"],
+        "type": normalized["type"],
+    }
 
 
-def _field_selector_payload_equal(left: Any, right: Any) -> bool:
-    if left is None and right is None:
-        return True
-    if not isinstance(left, dict) or not isinstance(right, dict):
+def _serialize_q_linker_alias_path_item(value: Any) -> dict[str, Any]:
+    normalized = _normalize_q_linker_alias_path_item(value) or {"alias_name": "", "alias_path": "", "alias_id": None, "alias_type": 1}
+    payload = {
+        "aliasName": normalized["alias_name"],
+        "aliasPath": normalized["alias_path"],
+        "aliasType": normalized.get("alias_type") or 1,
+    }
+    if normalized.get("alias_id") is not None:
+        payload["aliasId"] = normalized["alias_id"]
+    return payload
+
+
+def _normalize_q_linker_binding_input_item(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    raw_field = value.get("field")
+    if isinstance(raw_field, str):
+        raw_field = {"name": raw_field}
+    if not isinstance(raw_field, dict):
+        return None
+    key = str(value.get("key") or "").strip()
+    source = str(value.get("source") or "").strip().lower()
+    if not key or not source:
+        return None
+    payload = {
+        "field": {
+            "field_id": str(raw_field.get("field_id") or "").strip() or None,
+            "que_id": _coerce_positive_int(raw_field.get("que_id")),
+            "name": str(raw_field.get("name") or "").strip() or None,
+        },
+        "key": key,
+        "source": source,
+    }
+    if not any(payload["field"].values()):
+        return None
+    return payload
+
+
+def _normalize_q_linker_binding_output_item(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    alias = str(value.get("alias", value.get("alias_name", value.get("aliasName", ""))) or "").strip()
+    path = str(value.get("path", value.get("alias_path", value.get("aliasPath", ""))) or "").strip()
+    raw_target = value.get("target_field", value.get("targetField"))
+    if isinstance(raw_target, str):
+        raw_target = {"name": raw_target}
+    if not alias or not path:
+        return None
+    target_field = {
+        "field_id": None,
+        "que_id": None,
+        "name": None,
+    }
+    if isinstance(raw_target, dict):
+        target_field = {
+            "field_id": str(raw_target.get("field_id") or "").strip() or None,
+            "que_id": _coerce_positive_int(raw_target.get("que_id")),
+            "name": str(raw_target.get("name") or "").strip() or None,
+        }
+        if not any(target_field.values()):
+            target_field = None
+    else:
+        target_field = None
+    return {
+        "alias": alias,
+        "path": path,
+        "alias_id": _coerce_positive_int(value.get("alias_id", value.get("aliasId"))),
+        "target_field": target_field,
+    }
+
+
+def _normalize_q_linker_request(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    return {
+        "url": str(value.get("url") or ""),
+        "method": str(value.get("method") or "GET").upper() or "GET",
+        "headers": [
+            item for item in (_normalize_q_linker_key_value_item(raw) for raw in cast(list[Any], value.get("headers") or [])) if item is not None
+        ] if isinstance(value.get("headers"), list) else [],
+        "query_params": [
+            item for item in (_normalize_q_linker_key_value_item(raw) for raw in cast(list[Any], value.get("query_params", value.get("queryParams")) or [])) if item is not None
+        ] if isinstance(value.get("query_params", value.get("queryParams")), list) else [],
+        "body_type": _coerce_positive_int(value.get("body_type", value.get("bodyType"))) or 1,
+        "url_encoded_value": [
+            item for item in (_normalize_q_linker_key_value_item(raw) for raw in cast(list[Any], value.get("url_encoded_value", value.get("urlEncodedValue")) or [])) if item is not None
+        ] if isinstance(value.get("url_encoded_value", value.get("urlEncodedValue")), list) else [],
+        "json_value": None if value.get("json_value", value.get("jsonValue")) is None else str(value.get("json_value", value.get("jsonValue")) or ""),
+        "xml_value": None if value.get("xml_value", value.get("xmlValue")) is None else str(value.get("xml_value", value.get("xmlValue")) or ""),
+        "result_type": _coerce_positive_int(value.get("result_type", value.get("resultType"))) or 1,
+        "auto_trigger": None if value.get("auto_trigger", value.get("autoTrigger")) is None else bool(value.get("auto_trigger", value.get("autoTrigger"))),
+        "custom_button_text_enabled": None if value.get("custom_button_text_enabled", value.get("customButtonTextEnabled", value.get("custom_btn_text_status", value.get("customBtnTextStatus")))) is None else bool(value.get("custom_button_text_enabled", value.get("customButtonTextEnabled", value.get("custom_btn_text_status", value.get("customBtnTextStatus"))))),
+        "custom_button_text": None if value.get("custom_button_text", value.get("customButtonText", value.get("custom_btn_text", value.get("customBtnText")))) is None else str(value.get("custom_button_text", value.get("customButtonText", value.get("custom_btn_text", value.get("customBtnText")))) or ""),
+        "being_insert_value_directly": None if value.get("being_insert_value_directly", value.get("beingInsertValueDirectly")) is None else bool(value.get("being_insert_value_directly", value.get("beingInsertValueDirectly"))),
+        "being_hide_on_form": None if value.get("being_hide_on_form", value.get("beingHideOnForm")) is None else bool(value.get("being_hide_on_form", value.get("beingHideOnForm"))),
+    }
+
+
+def _normalize_q_linker_binding(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    request = _normalize_q_linker_request(value.get("request"))
+    if request is None:
+        return None
+    inputs = [
+        item for item in (_normalize_q_linker_binding_input_item(raw) for raw in cast(list[Any], value.get("inputs") or [])) if item is not None
+    ] if isinstance(value.get("inputs"), list) else []
+    outputs = [
+        item for item in (_normalize_q_linker_binding_output_item(raw) for raw in cast(list[Any], value.get("outputs") or [])) if item is not None
+    ] if isinstance(value.get("outputs"), list) else []
+    return {
+        "inputs": inputs,
+        "request": request,
+        "outputs": outputs,
+    }
+
+
+def _remote_lookup_config_equal(left: Any, right: Any) -> bool:
+    return _normalize_remote_lookup_config(left) == _normalize_remote_lookup_config(right)
+
+
+def _q_linker_binding_equal(left: Any, right: Any) -> bool:
+    return _normalize_q_linker_binding(left) == _normalize_q_linker_binding(right)
+
+
+def _compose_qlinker_value_reference(*, field_name: str, que_id: int) -> str:
+    return f"{{{field_name}$${_encrypt_question_id(que_id)}$$}}"
+
+
+def _attach_q_linker_binding_readback(*, parsed: dict[str, Any], raw_schema: dict[str, Any]) -> None:
+    fields = parsed.get("fields") if isinstance(parsed.get("fields"), list) else []
+    if not fields:
+        return
+    by_que_id = {
+        _coerce_positive_int(field.get("que_id")): field
+        for field in fields
+        if isinstance(field, dict) and _coerce_positive_int(field.get("que_id")) is not None
+    }
+    relations = raw_schema.get("questionRelations") if isinstance(raw_schema.get("questionRelations"), list) else []
+    relation_by_source: dict[int, list[dict[str, Any]]] = {}
+    for relation in relations:
+        if not isinstance(relation, dict) or _coerce_positive_int(relation.get("relationType")) != RELATION_TYPE_Q_LINKER:
+            continue
+        alias_config = relation.get("aliasConfig") if isinstance(relation.get("aliasConfig"), dict) else {}
+        source_que_id = _coerce_positive_int(alias_config.get("queId")) or _coerce_positive_int(relation.get("qlinkerQueId"))
+        target_que_id = _coerce_positive_int(relation.get("queId"))
+        alias_name = str(alias_config.get("qlinkerAlias") or relation.get("qlinkerAlias") or "").strip()
+        if source_que_id is None or target_que_id is None or not alias_name:
+            continue
+        relation_by_source.setdefault(source_que_id, []).append(
+            {
+                "alias": alias_name,
+                "target_que_id": target_que_id,
+            }
+        )
+    for field in fields:
+        if not isinstance(field, dict) or field.get("type") != FieldType.q_linker.value:
+            continue
+        remote_lookup_config = _normalize_remote_lookup_config(field.get("remote_lookup_config") or field.get("config") or {}) or {}
+        que_id = _coerce_positive_int(field.get("que_id"))
+        relation_items = relation_by_source.get(que_id or -1, [])
+        relation_by_alias = {str(item.get("alias") or ""): item for item in relation_items if str(item.get("alias") or "")}
+        inputs: list[dict[str, Any]] = []
+        static_headers: list[dict[str, Any]] = []
+        static_query_params: list[dict[str, Any]] = []
+        static_url_encoded: list[dict[str, Any]] = []
+        metadata_unverified = False
+        for source_name, config_items, static_bucket in (
+            ("header", cast(list[dict[str, Any]], remote_lookup_config.get("headers") or []), static_headers),
+            ("query_param", cast(list[dict[str, Any]], remote_lookup_config.get("query_params") or []), static_query_params),
+            ("url_encoded", cast(list[dict[str, Any]], remote_lookup_config.get("url_encoded_value") or []), static_url_encoded),
+        ):
+            for item in config_items:
+                if _coerce_positive_int(item.get("type")) == 2:
+                    source_field = by_que_id.get(_coerce_positive_int(item.get("value")))
+                    if isinstance(source_field, dict):
+                        inputs.append(
+                            {
+                                "field": {
+                                    "field_id": source_field.get("field_id"),
+                                    "que_id": source_field.get("que_id"),
+                                    "name": source_field.get("name"),
+                                },
+                                "key": item.get("key"),
+                                "source": source_name,
+                            }
+                        )
+                    else:
+                        metadata_unverified = True
+                else:
+                    static_bucket.append({"key": item.get("key"), "value": item.get("value")})
+        outputs: list[dict[str, Any]] = []
+        for alias_item in cast(list[dict[str, Any]], remote_lookup_config.get("result_format_path") or []):
+            alias_name = str(alias_item.get("alias_name") or "").strip()
+            if not alias_name:
+                continue
+            output_payload: dict[str, Any] = {
+                "alias": alias_name,
+                "path": str(alias_item.get("alias_path") or ""),
+                "alias_id": _coerce_positive_int(alias_item.get("alias_id")),
+            }
+            relation_item = relation_by_alias.get(alias_name)
+            if relation_item is not None:
+                target_field = by_que_id.get(_coerce_positive_int(relation_item.get("target_que_id")))
+                if isinstance(target_field, dict):
+                    output_payload["target_field"] = {
+                        "field_id": target_field.get("field_id"),
+                        "que_id": target_field.get("que_id"),
+                        "name": target_field.get("name"),
+                    }
+                else:
+                    metadata_unverified = True
+            else:
+                metadata_unverified = True
+            outputs.append(output_payload)
+        field["q_linker_binding"] = {
+            "inputs": inputs,
+            "request": {
+                "url": remote_lookup_config.get("url"),
+                "method": remote_lookup_config.get("method"),
+                "headers": static_headers,
+                "query_params": static_query_params,
+                "body_type": remote_lookup_config.get("body_type"),
+                "url_encoded_value": static_url_encoded,
+                "json_value": remote_lookup_config.get("json_value"),
+                "xml_value": remote_lookup_config.get("xml_value"),
+                "result_type": remote_lookup_config.get("result_type"),
+                "auto_trigger": remote_lookup_config.get("auto_trigger"),
+                "custom_button_text_enabled": remote_lookup_config.get("custom_button_text_enabled"),
+                "custom_button_text": remote_lookup_config.get("custom_button_text"),
+                "being_insert_value_directly": remote_lookup_config.get("being_insert_value_directly"),
+                "being_hide_on_form": remote_lookup_config.get("being_hide_on_form"),
+            },
+            "outputs": outputs,
+        }
+        if metadata_unverified:
+            field["metadata_unverified"] = True
+
+
+def _parse_code_block_inputs_and_body(code_content: str) -> tuple[list[dict[str, Any]], str]:
+    if not code_content:
+        return [], ""
+    lines = code_content.splitlines()
+    inputs: list[dict[str, Any]] = []
+    index = 0
+    while index < len(lines):
+        line = lines[index]
+        if not line.strip():
+            index += 1
+            continue
+        matched = _CODE_BLOCK_INPUT_LINE_RE.match(line)
+        if matched is None:
+            break
+        inputs.append({"field": {"name": matched.group("field")}, "var": matched.group("var")})
+        index += 1
+    body = "\n".join(lines[index:]).lstrip("\n")
+    return inputs, body
+
+
+def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any]) -> 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 "")),
+    }
+    if field.get("type") == FieldType.relation.value:
+        payload["target_app_key"] = field.get("target_app_key")
+        payload["relation_mode"] = _normalize_relation_mode(field.get("relation_mode"))
+        payload["display_field"] = deepcopy(field.get("display_field"))
+        payload["visible_fields"] = deepcopy(field.get("visible_fields") or [])
+    if field.get("type") == FieldType.code_block.value:
+        payload["code_block_config"] = deepcopy(field.get("code_block_config") or {})
+        if field.get("auto_trigger") is not None:
+            payload["auto_trigger"] = bool(field.get("auto_trigger"))
+        if field.get("custom_button_text_enabled") is not None:
+            payload["custom_button_text_enabled"] = bool(field.get("custom_button_text_enabled"))
+        if field.get("custom_button_text") is not None:
+            payload["custom_button_text"] = field.get("custom_button_text")
+        if field.get("code_block_binding") is not None:
+            payload["code_block_binding"] = deepcopy(field.get("code_block_binding"))
+        if field.get("metadata_unverified") is not None:
+            payload["metadata_unverified"] = bool(field.get("metadata_unverified"))
+    if field.get("type") == FieldType.q_linker.value:
+        payload["remote_lookup_config"] = deepcopy(field.get("remote_lookup_config") or {})
+        if field.get("q_linker_binding") is not None:
+            payload["q_linker_binding"] = deepcopy(field.get("q_linker_binding"))
+        if field.get("auto_trigger") is not None:
+            payload["auto_trigger"] = bool(field.get("auto_trigger"))
+        if field.get("custom_button_text_enabled") is not None:
+            payload["custom_button_text_enabled"] = bool(field.get("custom_button_text_enabled"))
+        if field.get("custom_button_text") is not None:
+            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"))
+    return payload
+
+
+def _build_selector_map(fields: list[dict[str, Any]]) -> dict[str, int]:
+    mapping: dict[str, int] = {}
+    for index, field in enumerate(fields):
+        field_id = str(field.get("field_id") or "")
+        field_name = str(field.get("name") or "")
+        que_id = _coerce_positive_int(field.get("que_id"))
+        if field_id:
+            mapping[f"field_id:{field_id}"] = index
+        if field_name:
+            mapping[f"name:{field_name}"] = index
+        if que_id is not None:
+            mapping[f"que_id:{que_id}"] = index
+    return mapping
+
+
+def _resolve_selector(selector_map: dict[str, int], selector: FieldSelector) -> int | None:
+    if selector.field_id:
+        value = selector_map.get(f"field_id:{selector.field_id}")
+        if value is not None:
+            return value
+    if selector.que_id:
+        value = selector_map.get(f"que_id:{selector.que_id}")
+        if value is not None:
+            return value
+    if selector.name:
+        value = selector_map.get(f"name:{selector.name}")
+        if value is not None:
+            return value
+    return None
+
+
+def _resolve_remove_selector(fields: list[dict[str, Any]], patch: FieldRemovePatch) -> int | None:
+    selector = FieldSelector(field_id=patch.field_id, que_id=patch.que_id, name=patch.name)
+    return _resolve_selector(_build_selector_map(fields), selector)
+
+
+def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
+    field_id = _slugify(patch.name, default=f"field_{uuid4().hex[:8]}")
+    remote_lookup_config = patch.remote_lookup_config.model_dump(mode="json", exclude_none=True) if patch.remote_lookup_config is not None else None
+    q_linker_binding = patch.q_linker_binding.model_dump(mode="json", exclude_none=True) if patch.q_linker_binding is not None else None
+    code_block_config = patch.code_block_config.model_dump(mode="json", exclude_none=True) if patch.code_block_config is not None else None
+    code_block_binding = patch.code_block_binding.model_dump(mode="json", exclude_none=True) if patch.code_block_binding is not None else None
+    return {
+        "field_id": field_id,
+        "name": patch.name,
+        "type": patch.type.value,
+        "required": patch.required,
+        "description": patch.description,
+        "options": list(patch.options),
+        "target_app_key": patch.target_app_key,
+        "display_field": patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None,
+        "visible_fields": [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields],
+        "relation_mode": patch.relation_mode.value if patch.relation_mode is not None else None,
+        "remote_lookup_config": remote_lookup_config,
+        "_explicit_remote_lookup_config": remote_lookup_config is not None,
+        "q_linker_binding": q_linker_binding,
+        "code_block_config": code_block_config,
+        "code_block_binding": code_block_binding,
+        "config": deepcopy(remote_lookup_config) if remote_lookup_config is not None else (deepcopy(code_block_config) if code_block_config is not None else {}),
+        "auto_trigger": patch.auto_trigger,
+        "custom_button_text_enabled": patch.custom_button_text_enabled,
+        "custom_button_text": patch.custom_button_text,
+        "subfields": [_field_patch_to_internal(subfield) for subfield in patch.subfields],
+        "que_id": None,
+        "default_type": 1,
+        "default_value": None,
+    }
+
+
+def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
+    return (
+        str(field.get("name") or "") == patch.name
+        and str(field.get("type") or "") == patch.type.value
+        and bool(field.get("required")) == patch.required
+        and (field.get("description") or None) == patch.description
+        and list(field.get("options") or []) == list(patch.options)
+        and (field.get("target_app_key") or None) == patch.target_app_key
+        and _field_selector_payload_equal(field.get("display_field"), patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None)
+        and _field_selector_list_equal(field.get("visible_fields"), [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields])
+        and _normalize_relation_mode(field.get("relation_mode")) == _normalize_relation_mode(patch.relation_mode.value if patch.relation_mode is not None else None)
+        and _remote_lookup_config_equal(field.get("remote_lookup_config"), patch.remote_lookup_config.model_dump(mode="json", exclude_none=True) if patch.remote_lookup_config is not None else None)
+        and _q_linker_binding_equal(field.get("q_linker_binding"), patch.q_linker_binding.model_dump(mode="json", exclude_none=True) if patch.q_linker_binding is not None else None)
+        and _code_block_config_equal(field.get("code_block_config"), patch.code_block_config.model_dump(mode="json", exclude_none=True) if patch.code_block_config is not None else None)
+        and _code_block_binding_equal(field.get("code_block_binding"), patch.code_block_binding.model_dump(mode="json", exclude_none=True) if patch.code_block_binding is not None else None)
+        and _optional_bool_equal(field.get("auto_trigger"), patch.auto_trigger)
+        and _optional_bool_equal(field.get("custom_button_text_enabled"), patch.custom_button_text_enabled)
+        and _optional_string_equal(field.get("custom_button_text"), patch.custom_button_text)
+        and len(field.get("subfields") or []) == len(patch.subfields)
+    )
+
+
+def _field_selector_payload_equal(left: Any, right: Any) -> bool:
+    if left is None and right is None:
+        return True
+    if not isinstance(left, dict) or not isinstance(right, dict):
         return False
     return (
         str(left.get("field_id") or "") == str(right.get("field_id") or "")
@@ -7662,6 +8497,146 @@ def _field_selector_list_equal(left: Any, right: Any) -> bool:
     return all(_field_selector_payload_equal(item_left, item_right) for item_left, item_right in zip(left_items, right_items))
 
 
+def _optional_bool_equal(left: Any, right: Any) -> bool:
+    if left is None and right is None:
+        return True
+    return bool(left) == bool(right)
+
+
+def _optional_string_equal(left: Any, right: Any) -> bool:
+    if left is None and right is None:
+        return True
+    return str(left or "") == str(right or "")
+
+
+def _normalize_code_block_alias_path_item(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    payload = {
+        "alias_name": str(value.get("alias_name", value.get("aliasName", "")) or "").strip(),
+        "alias_path": str(value.get("alias_path", value.get("aliasPath", "")) or "").strip(),
+        "alias_type": _coerce_positive_int(value.get("alias_type", value.get("aliasType"))) or 1,
+        "alias_id": _coerce_positive_int(value.get("alias_id", value.get("aliasId"))),
+        "sub_alias": [],
+    }
+    sub_alias_raw = value.get("sub_alias", value.get("subAlias"))
+    if isinstance(sub_alias_raw, list):
+        payload["sub_alias"] = [
+            item for item in (_normalize_code_block_alias_path_item(sub_item) for sub_item in sub_alias_raw) if item is not None
+        ]
+    return payload
+
+
+def _normalize_code_block_config(value: Any) -> dict[str, Any] | None:
+    if value is None:
+        return None
+    if not isinstance(value, dict):
+        return None
+    result_alias_path_raw = value.get("result_alias_path", value.get("resultAliasPath", value.get("alias_config", value.get("aliasConfig"))))
+    result_alias_path = []
+    if isinstance(result_alias_path_raw, list):
+        result_alias_path = [
+            item for item in (_normalize_code_block_alias_path_item(alias) for alias in result_alias_path_raw) if item is not None
+        ]
+    return {
+        "config_mode": _coerce_positive_int(value.get("config_mode", value.get("configMode"))) or 1,
+        "code_content": str(value.get("code_content", value.get("codeContent", "")) or ""),
+        "being_hide_on_form": bool(value.get("being_hide_on_form", value.get("beingHideOnForm", False))),
+        "result_alias_path": result_alias_path,
+    }
+
+
+def _code_block_config_equal(left: Any, right: Any) -> bool:
+    return _normalize_code_block_config(left) == _normalize_code_block_config(right)
+
+
+def _normalize_code_block_binding_input_item(value: Any) -> dict[str, Any] | None:
+    if isinstance(value, str):
+        return {"field": {"name": value}, "var": None}
+    if not isinstance(value, dict):
+        return None
+    raw_field = value.get("field")
+    if isinstance(raw_field, str):
+        raw_field = {"name": raw_field}
+    elif not isinstance(raw_field, dict):
+        for key in ("field_name", "fieldName", "name", "title", "label"):
+            raw_value = value.get(key)
+            if isinstance(raw_value, str) and raw_value.strip():
+                raw_field = {"name": raw_value.strip()}
+                break
+    if not isinstance(raw_field, dict):
+        return None
+    payload = {
+        "field": {
+            "field_id": str(raw_field.get("field_id") or "").strip() or None,
+            "que_id": _coerce_positive_int(raw_field.get("que_id")),
+            "name": str(raw_field.get("name") or "").strip() or None,
+        },
+        "var": str(value.get("var") or "").strip() or None,
+    }
+    if not any(payload["field"].values()):
+        return None
+    return payload
+
+
+def _normalize_code_block_binding_output_item(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    alias = str(value.get("alias", value.get("alias_name", value.get("aliasName", ""))) or "").strip()
+    path = str(value.get("path", value.get("alias_path", value.get("aliasPath", ""))) or "").strip()
+    raw_target = value.get("target_field", value.get("targetField"))
+    if isinstance(raw_target, str):
+        raw_target = {"name": raw_target}
+    target_field = None
+    if isinstance(raw_target, dict):
+        target_field = {
+            "field_id": str(raw_target.get("field_id") or "").strip() or None,
+            "que_id": _coerce_positive_int(raw_target.get("que_id")),
+            "name": str(raw_target.get("name") or "").strip() or None,
+        }
+        if not any(target_field.values()):
+            target_field = None
+    if not alias or not path:
+        return None
+    return {
+        "alias": alias,
+        "path": path,
+        "alias_id": _coerce_positive_int(value.get("alias_id", value.get("aliasId"))),
+        "target_field": target_field,
+    }
+
+
+def _normalize_code_block_binding(value: Any) -> dict[str, Any] | None:
+    if value is None or not isinstance(value, dict):
+        return None
+    inputs = []
+    outputs = []
+    if isinstance(value.get("inputs"), list):
+        inputs = [
+            item
+            for item in (_normalize_code_block_binding_input_item(raw_item) for raw_item in cast(list[Any], value.get("inputs") or []))
+            if item is not None
+        ]
+    if isinstance(value.get("outputs"), list):
+        outputs = [
+            item
+            for item in (_normalize_code_block_binding_output_item(raw_item) for raw_item in cast(list[Any], value.get("outputs") or []))
+            if item is not None
+        ]
+    return {
+        "inputs": inputs,
+        "code": str(value.get("code", value.get("code_content", value.get("codeContent", ""))) or ""),
+        "auto_trigger": None if value.get("auto_trigger", value.get("autoTrigger")) is None else bool(value.get("auto_trigger", value.get("autoTrigger"))),
+        "custom_button_text_enabled": None if value.get("custom_button_text_enabled", value.get("customButtonTextEnabled", value.get("custom_btn_text_status", value.get("customBtnTextStatus")))) is None else bool(value.get("custom_button_text_enabled", value.get("customButtonTextEnabled", value.get("custom_btn_text_status", value.get("customBtnTextStatus"))))),
+        "custom_button_text": None if value.get("custom_button_text", value.get("customButtonText", value.get("custom_btn_text", value.get("customBtnText")))) is None else str(value.get("custom_button_text", value.get("customButtonText", value.get("custom_btn_text", value.get("customBtnText")))) or ""),
+        "outputs": outputs,
+    }
+
+
+def _code_block_binding_equal(left: Any, right: Any) -> bool:
+    return _normalize_code_block_binding(left) == _normalize_code_block_binding(right)
+
+
 def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
     payload = mutation.model_dump(mode="json", exclude_none=True)
     if "name" in payload:
@@ -7682,10 +8657,785 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         field["visible_fields"] = list(payload["visible_fields"])
     if "relation_mode" in payload:
         field["relation_mode"] = payload["relation_mode"]
+    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
+    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
+    if "code_block_config" in payload:
+        field["code_block_config"] = payload["code_block_config"]
+        field["config"] = deepcopy(payload["code_block_config"])
+    if "code_block_binding" in payload:
+        field["code_block_binding"] = payload["code_block_binding"]
+    if "auto_trigger" in payload:
+        field["auto_trigger"] = payload["auto_trigger"]
+    if "custom_button_text_enabled" in payload:
+        field["custom_button_text_enabled"] = payload["custom_button_text_enabled"]
+    if "custom_button_text" in payload:
+        field["custom_button_text"] = payload["custom_button_text"]
     if "subfields" in payload:
         field["subfields"] = [_field_patch_to_internal(item) for item in payload["subfields"]]
 
 
+def _resolve_field_selector_with_uniqueness(
+    *,
+    fields: list[dict[str, Any]],
+    selector_payload: dict[str, Any],
+    location: str,
+) -> dict[str, Any]:
+    selector = FieldSelector.model_validate(selector_payload)
+    if selector.field_id:
+        matched = [field for field in fields if str(field.get("field_id") or "") == str(selector.field_id)]
+    elif selector.que_id:
+        matched = [field for field in fields if _coerce_positive_int(field.get("que_id")) == _coerce_positive_int(selector.que_id)]
+    elif selector.name:
+        name = str(selector.name or "").strip()
+        matched = [field for field in fields if str(field.get("name") or "").strip() == name]
+        if len(matched) > 1:
+            raise ValueError(f"{location} matched multiple fields with the same name; use field_id or que_id")
+    else:
+        matched = []
+    if len(matched) != 1:
+        raise ValueError(f"{location} could not be resolved")
+    return matched[0]
+
+
+def _default_code_block_input_var(*, field_name: str, que_id: int | None, index: int) -> str:
+    seed = _slugify(field_name, default="")
+    if seed:
+        parts = [part for part in re.split(r"[-_]+", seed) if part]
+        candidate = parts[0] + "".join(part.capitalize() for part in parts[1:])
+        if candidate and re.match(r"^[A-Za-z_$][A-Za-z0-9_$]*$", candidate):
+            return candidate
+    return f"field_{que_id or index + 1}"
+
+
+def _encrypt_question_id(que_id: int) -> str:
+    have_prefix = que_id < 0
+    abs_que_id = abs(que_id)
+    result_length = 4
+    ran = abs_que_id * 17
+    inp = str(abs_que_id)
+    seeds: list[int] = []
+    total = 0
+    key = 1000013
+    for _ in range(max(result_length - len(inp), 0)):
+        tmp = (ran % 20) + 71
+        ran = ((ran + 13) * 17) % key
+        total += tmp
+        seeds.append(tmp)
+    result = [((total + index + int(char, 16)) % 15) for index, char in enumerate(inp)]
+    for seed in seeds:
+        position = (ran + seed) % len(result)
+        ran = ((ran + 13) * 17) % key
+        result.insert(position, seed)
+    rendered = "".join(chr(item) if item > 15 else format(item, "X") for item in result)
+    return f"-{rendered}" if have_prefix else rendered
+
+
+def _compose_code_block_input_reference(*, field_name: str, que_id: int) -> str:
+    return f"qf_field.{{{field_name}$${_encrypt_question_id(que_id)}$$}}"
+
+
+def _strip_code_block_generated_input_prelude(code_content: str) -> str:
+    _inputs, body = _parse_code_block_inputs_and_body(code_content)
+    return body
+
+
+def _normalize_code_block_output_assignment(code_content: str) -> str:
+    return re.sub(r"(?m)^(\s*)(?:const|let)\s+qf_output\s*=", r"\1qf_output =", code_content)
+
+
+def _ensure_field_temp_ids(fields: list[dict[str, Any]]) -> None:
+    temp_id = -10000
+    for field in fields:
+        if not isinstance(field, dict):
+            continue
+        if _coerce_positive_int(field.get("que_id")) is None and _coerce_any_int(field.get("que_temp_id")) is None:
+            field["que_temp_id"] = temp_id
+        temp_id -= 100
+
+
+def _compile_code_block_binding_fields(
+    *,
+    fields: list[dict[str, Any]],
+    current_schema: dict[str, Any],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    next_fields = deepcopy(fields)
+    _ensure_field_temp_ids(next_fields)
+    by_name = {
+        str(field.get("name") or ""): field
+        for field in next_fields
+        if isinstance(field, dict) and str(field.get("name") or "")
+    }
+    existing_relations = current_schema.get("questionRelations") if isinstance(current_schema.get("questionRelations"), list) else []
+    relation_specs: list[dict[str, Any]] = []
+    affected_source_refs: set[int] = set()
+    affected_target_refs: set[int] = set()
+    for field in next_fields:
+        if not isinstance(field, dict) or field.get("type") != FieldType.code_block.value:
+            continue
+        binding = _normalize_code_block_binding(field.get("code_block_binding"))
+        if binding is None:
+            continue
+        current_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or {
+            "config_mode": 1,
+            "code_content": "",
+            "being_hide_on_form": False,
+            "result_alias_path": [],
+        }
+        low_level_code = _strip_code_block_generated_input_prelude(str(current_config.get("code_content") or ""))
+        if str(current_config.get("code_content") or "").strip() and low_level_code != str(binding.get("code") or ""):
+            raise ValueError(f"code_block field '{field.get('name')}' has conflicting code_block_config.code_content and code_block_binding.code")
+        compiled_inputs: list[dict[str, Any]] = []
+        input_lines: list[str] = []
+        for index, input_item in enumerate(cast(list[dict[str, Any]], binding.get("inputs") or [])):
+            source_field = _resolve_field_selector_with_uniqueness(
+                fields=next_fields,
+                selector_payload=cast(dict[str, Any], input_item.get("field") or {}),
+                location=f"code_block_binding.inputs[{index}].field",
+            )
+            source_que_id = _coerce_positive_int(source_field.get("que_id"))
+            if source_que_id is None:
+                source_que_id = _coerce_any_int(source_field.get("que_temp_id"))
+            if source_que_id is None:
+                raise ValueError(f"code_block input field '{source_field.get('name')}' does not have a stable que_id")
+            variable_name = str(input_item.get("var") or "").strip() or _default_code_block_input_var(
+                field_name=str(source_field.get("name") or ""),
+                que_id=source_que_id,
+                index=index,
+            )
+            if not re.match(r"^[A-Za-z_$][A-Za-z0-9_$]*$", variable_name):
+                raise ValueError(f"code_block_binding.inputs[{index}].var must be a valid JavaScript identifier")
+            compiled_inputs.append({"field": {"name": source_field.get("name"), "que_id": source_que_id}, "var": variable_name})
+            input_lines.append(f"const {variable_name} = {_compose_code_block_input_reference(field_name=str(source_field.get('name') or ''), que_id=source_que_id)};")
+        compiled_outputs: list[dict[str, Any]] = []
+        existing_alias_by_name = {
+            str(item.get("alias_name") or ""): item
+            for item in cast(list[dict[str, Any]], current_config.get("result_alias_path") or [])
+            if str(item.get("alias_name") or "")
+        }
+        body = _normalize_code_block_output_assignment(str(binding.get("code") or ""))
+        compiled_code = "\n".join(input_lines + ([body] if body else [])).strip()
+        for output_index, output_item in enumerate(cast(list[dict[str, Any]], binding.get("outputs") or [])):
+            alias_name = str(output_item.get("alias") or "").strip()
+            alias_path = str(output_item.get("path") or "").strip()
+            existing_alias = existing_alias_by_name.get(alias_name) or {}
+            alias_id = _coerce_positive_int(existing_alias.get("alias_id"))
+            compiled_outputs.append(
+                {
+                    "alias_name": alias_name,
+                    "alias_path": alias_path,
+                    "alias_type": 1,
+                    "alias_id": alias_id,
+                    "sub_alias": [],
+                }
+            )
+            target_payload = output_item.get("target_field")
+            if not isinstance(target_payload, dict):
+                raise ValueError(f"code_block_binding.outputs[{output_index}].target_field is required")
+            target_field = _resolve_field_selector_with_uniqueness(
+                fields=next_fields,
+                selector_payload=target_payload,
+                location=f"code_block_binding.outputs[{output_index}].target_field",
+            )
+            if str(target_field.get("type") or "") in {FieldType.code_block.value, FieldType.subtable.value, FieldType.relation.value}:
+                raise ValueError(f"code_block output target field '{target_field.get('name')}' uses an unsupported field type")
+            target_que_ref = _coerce_positive_int(target_field.get("que_id"))
+            if target_que_ref is None:
+                target_que_ref = _coerce_any_int(target_field.get("que_temp_id"))
+            compiled_outputs[-1]["target_field"] = {
+                "field_id": target_field.get("field_id"),
+                "que_id": target_que_ref,
+                "name": target_field.get("name"),
+            }
+        current_config["code_content"] = compiled_code
+        current_config["result_alias_path"] = compiled_outputs
+        field["code_block_config"] = current_config
+        field["config"] = deepcopy(current_config)
+        field["auto_trigger"] = binding.get("auto_trigger")
+        field["custom_button_text_enabled"] = binding.get("custom_button_text_enabled")
+        field["custom_button_text"] = binding.get("custom_button_text")
+        field["code_block_binding"] = {
+            "inputs": compiled_inputs,
+            "code": body,
+            "auto_trigger": binding.get("auto_trigger"),
+            "custom_button_text_enabled": binding.get("custom_button_text_enabled"),
+            "custom_button_text": binding.get("custom_button_text"),
+            "outputs": compiled_outputs,
+        }
+        source_ref = _coerce_positive_int(field.get("que_id"))
+        if source_ref is None:
+            source_ref = _coerce_any_int(field.get("que_temp_id"))
+        if source_ref is not None:
+            affected_source_refs.add(source_ref)
+        for output_item in compiled_outputs:
+            target_payload = output_item.get("target_field")
+            if not isinstance(target_payload, dict):
+                continue
+            target_field = by_name.get(str(target_payload.get("name") or ""))
+            if not isinstance(target_field, dict):
+                continue
+            target_ref = _coerce_positive_int(target_field.get("que_id"))
+            if target_ref is None:
+                target_ref = _coerce_any_int(target_field.get("que_temp_id"))
+            if target_ref is None or source_ref is None:
+                continue
+            target_field["default_type"] = DEFAULT_TYPE_RELATION
+            affected_target_refs.add(target_ref)
+            relation_specs.append(
+                {
+                    "source_field_name": field.get("name"),
+                    "source_field_ref": source_ref,
+                    "target_field_name": target_field.get("name"),
+                    "target_field_ref": target_ref,
+                    "alias": output_item.get("alias_name"),
+                    "alias_id": _coerce_positive_int(output_item.get("alias_id")),
+                }
+            )
+    carried_relations: list[dict[str, Any]] = []
+    for relation in existing_relations:
+        if not isinstance(relation, dict):
+            continue
+        if _coerce_positive_int(relation.get("relationType")) != RELATION_TYPE_CODE_BLOCK:
+            carried_relations.append(deepcopy(relation))
+            continue
+        alias_config = relation.get("aliasConfig") if isinstance(relation.get("aliasConfig"), dict) else {}
+        source_ref = _coerce_positive_int(alias_config.get("queId"))
+        target_ref = _coerce_positive_int(relation.get("queId"))
+        if (source_ref is not None and source_ref in affected_source_refs) or (target_ref is not None and target_ref in affected_target_refs):
+            continue
+        carried_relations.append(deepcopy(relation))
+    carried_relations.extend(_materialize_code_block_question_relations(fields=next_fields, relation_specs=relation_specs))
+    existing_target_refs = _collect_code_block_relation_target_refs(cast(list[dict[str, Any]], existing_relations))
+    final_target_refs = _collect_code_block_relation_target_refs(carried_relations)
+    for field in next_fields:
+        if not isinstance(field, dict):
+            continue
+        field_ref = _coerce_positive_int(field.get("que_id"))
+        if field_ref is None:
+            field_ref = _coerce_any_int(field.get("que_temp_id"))
+        if field_ref is None or field_ref not in existing_target_refs:
+            continue
+        if field_ref in final_target_refs:
+            field["default_type"] = DEFAULT_TYPE_RELATION
+            continue
+        if _coerce_any_int(field.get("default_type")) == DEFAULT_TYPE_RELATION:
+            field["default_type"] = 1
+    return next_fields, carried_relations
+
+
+def _materialize_code_block_question_relations(
+    fields: list[dict[str, Any]],
+    relation_specs: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    by_name = {str(field.get("name") or ""): field for field in fields if isinstance(field, dict) and str(field.get("name") or "")}
+    materialized: list[dict[str, Any]] = []
+    for relation in relation_specs:
+        if not isinstance(relation, dict):
+            continue
+        if _coerce_positive_int(relation.get("relationType")) == RELATION_TYPE_CODE_BLOCK:
+            materialized.append(deepcopy(relation))
+            continue
+        source_field = by_name.get(str(relation.get("source_field_name") or ""))
+        target_field = by_name.get(str(relation.get("target_field_name") or ""))
+        if not isinstance(source_field, dict) or not isinstance(target_field, dict):
+            continue
+        source_ref = _coerce_positive_int(source_field.get("que_id"))
+        if source_ref is None:
+            source_ref = _coerce_any_int(source_field.get("que_temp_id"))
+        if source_ref is None:
+            source_ref = _coerce_any_int(relation.get("source_field_ref"))
+        target_ref = _coerce_positive_int(target_field.get("que_id"))
+        if target_ref is None:
+            target_ref = _coerce_any_int(target_field.get("que_temp_id"))
+        if target_ref is None:
+            target_ref = _coerce_any_int(relation.get("target_field_ref"))
+        if source_ref is None or target_ref is None:
+            continue
+        materialized.append(
+            {
+                "queId": target_ref,
+                "relationType": RELATION_TYPE_CODE_BLOCK,
+                "displayedQueId": None,
+                "displayedQueInfo": None,
+                "qlinkerAlias": relation.get("alias"),
+                "aliasConfig": {
+                    "queId": source_ref,
+                    "queTitle": source_field.get("name"),
+                    "qlinkerAlias": relation.get("alias"),
+                    "aliasId": _coerce_positive_int(relation.get("alias_id")),
+                },
+                "matchRuleType": 1,
+                "matchRules": [],
+                "matchRuleFormula": None,
+                "tableMatchRules": [],
+                "sortConfig": None,
+            }
+        )
+    return materialized
+
+
+def _collect_code_block_relation_target_refs(relations: list[dict[str, Any]]) -> set[int]:
+    target_refs: set[int] = set()
+    for relation in relations:
+        if not isinstance(relation, dict):
+            continue
+        if _coerce_positive_int(relation.get("relationType")) != RELATION_TYPE_CODE_BLOCK:
+            continue
+        target_ref = _coerce_any_int(relation.get("queId"))
+        if target_ref is not None:
+            target_refs.add(target_ref)
+    return target_refs
+
+
+def _code_block_relations_need_source_rebind(question_relations: list[dict[str, Any]]) -> bool:
+    for relation in question_relations:
+        if not isinstance(relation, dict):
+            continue
+        if _coerce_positive_int(relation.get("relationType")) != RELATION_TYPE_CODE_BLOCK:
+            continue
+        alias_config = relation.get("aliasConfig") if isinstance(relation.get("aliasConfig"), dict) else {}
+        source_ref = _coerce_any_int(alias_config.get("queId"))
+        alias_id = _coerce_positive_int(alias_config.get("aliasId"))
+        if (source_ref is not None and source_ref <= 0) or alias_id is None:
+            return True
+    return False
+
+
+def _overlay_code_block_binding_fields(*, target_fields: list[dict[str, Any]], source_fields: list[dict[str, Any]]) -> None:
+    source_by_name = {
+        str(field.get("name") or ""): field
+        for field in source_fields
+        if isinstance(field, dict) and str(field.get("name") or "")
+    }
+    for field in target_fields:
+        if not isinstance(field, dict):
+            continue
+        source = source_by_name.get(str(field.get("name") or ""))
+        if not isinstance(source, dict):
+            continue
+        if source.get("code_block_binding") is not None:
+            binding = deepcopy(source.get("code_block_binding"))
+            if isinstance(binding, dict):
+                for input_item in binding.get("inputs") or []:
+                    if not isinstance(input_item, dict):
+                        continue
+                    selector = input_item.get("field")
+                    if isinstance(selector, dict):
+                        selector["field_id"] = None
+                        if _coerce_positive_int(selector.get("que_id")) is None:
+                            selector["que_id"] = None
+                for output_item in binding.get("outputs") or []:
+                    if not isinstance(output_item, dict):
+                        continue
+                    selector = output_item.get("target_field")
+                    if isinstance(selector, dict):
+                        selector["field_id"] = None
+                        if _coerce_positive_int(selector.get("que_id")) is None:
+                            selector["que_id"] = None
+            field["code_block_binding"] = binding
+
+
+def _q_linker_target_type_supported(field_type: str) -> bool:
+    return field_type in {
+        FieldType.text.value,
+        FieldType.long_text.value,
+        FieldType.number.value,
+        FieldType.amount.value,
+        FieldType.date.value,
+        FieldType.datetime.value,
+        FieldType.single_select.value,
+        FieldType.multi_select.value,
+        FieldType.boolean.value,
+    }
+
+
+def _compile_q_linker_binding_fields(
+    *,
+    fields: list[dict[str, Any]],
+    current_schema: dict[str, Any],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    next_fields = deepcopy(fields)
+    _ensure_field_temp_ids(next_fields)
+    by_name = {
+        str(field.get("name") or ""): field
+        for field in next_fields
+        if isinstance(field, dict) and str(field.get("name") or "")
+    }
+    existing_relations = current_schema.get("questionRelations") if isinstance(current_schema.get("questionRelations"), list) else []
+    relation_specs: list[dict[str, Any]] = []
+    affected_source_refs: set[int] = set()
+    affected_target_refs: set[int] = set()
+    for field in next_fields:
+        if not isinstance(field, dict) or field.get("type") != FieldType.q_linker.value:
+            continue
+        binding = _normalize_q_linker_binding(field.get("q_linker_binding"))
+        if binding is None:
+            continue
+        current_config_source = field.get("remote_lookup_config")
+        current_config_raw = _normalize_remote_lookup_config(current_config_source) if current_config_source is not None else None
+        explicit_remote_lookup_config = bool(field.get("_explicit_remote_lookup_config"))
+        current_config = current_config_raw or {
+            "config_mode": 1,
+            "url": "",
+            "method": "GET",
+            "headers": [],
+            "body_type": 1,
+            "url_encoded_value": [],
+            "json_value": None,
+            "xml_value": None,
+            "result_type": 1,
+            "result_format_path": [],
+            "query_params": [],
+            "auto_trigger": None,
+            "custom_button_text_enabled": None,
+            "custom_button_text": None,
+            "being_insert_value_directly": None,
+            "being_hide_on_form": None,
+        }
+        request = _normalize_q_linker_request(binding.get("request")) or {
+            "url": "",
+            "method": "GET",
+            "headers": [],
+            "query_params": [],
+            "body_type": 1,
+            "url_encoded_value": [],
+            "json_value": None,
+            "xml_value": None,
+            "result_type": 1,
+            "auto_trigger": None,
+            "custom_button_text_enabled": None,
+            "custom_button_text": None,
+            "being_insert_value_directly": None,
+            "being_hide_on_form": None,
+        }
+        if int(request.get("config_mode") or 1) != 1:
+            raise ValueError(f"q_linker field '{field.get('name')}' currently only supports custom config_mode=1")
+        request_view = {
+            "config_mode": 1,
+            "url": request.get("url"),
+            "method": request.get("method"),
+            "headers": request.get("headers") or [],
+            "body_type": request.get("body_type"),
+            "url_encoded_value": request.get("url_encoded_value") or [],
+            "json_value": request.get("json_value"),
+            "xml_value": request.get("xml_value"),
+            "result_type": request.get("result_type"),
+            "result_format_path": [],
+            "query_params": request.get("query_params") or [],
+            "auto_trigger": request.get("auto_trigger"),
+            "custom_button_text_enabled": request.get("custom_button_text_enabled"),
+            "custom_button_text": request.get("custom_button_text"),
+            "being_insert_value_directly": request.get("being_insert_value_directly"),
+            "being_hide_on_form": request.get("being_hide_on_form"),
+        }
+        current_view = {
+            "config_mode": current_config.get("config_mode"),
+            "url": current_config.get("url"),
+            "method": current_config.get("method"),
+            "headers": current_config.get("headers") or [],
+            "body_type": current_config.get("body_type"),
+            "url_encoded_value": current_config.get("url_encoded_value") or [],
+            "json_value": current_config.get("json_value"),
+            "xml_value": current_config.get("xml_value"),
+            "result_type": current_config.get("result_type"),
+            "result_format_path": [],
+            "query_params": current_config.get("query_params") or [],
+            "auto_trigger": current_config.get("auto_trigger"),
+            "custom_button_text_enabled": current_config.get("custom_button_text_enabled"),
+            "custom_button_text": current_config.get("custom_button_text"),
+            "being_insert_value_directly": current_config.get("being_insert_value_directly"),
+            "being_hide_on_form": current_config.get("being_hide_on_form"),
+        }
+        if explicit_remote_lookup_config and current_config_raw is not None and current_view != request_view:
+            raise ValueError(f"q_linker field '{field.get('name')}' has conflicting remote_lookup_config and q_linker_binding.request")
+
+        compiled_inputs: list[dict[str, Any]] = []
+        compiled_headers = deepcopy(cast(list[dict[str, Any]], request.get("headers") or []))
+        compiled_query_params = deepcopy(cast(list[dict[str, Any]], request.get("query_params") or []))
+        compiled_url_encoded = deepcopy(cast(list[dict[str, Any]], request.get("url_encoded_value") or []))
+        compiled_url = str(request.get("url") or "")
+        compiled_json_value = None if request.get("json_value") is None else str(request.get("json_value") or "")
+        compiled_xml_value = None if request.get("xml_value") is None else str(request.get("xml_value") or "")
+        for index, input_item in enumerate(cast(list[dict[str, Any]], binding.get("inputs") or [])):
+            source_field = _resolve_field_selector_with_uniqueness(
+                fields=next_fields,
+                selector_payload=cast(dict[str, Any], input_item.get("field") or {}),
+                location=f"q_linker_binding.inputs[{index}].field",
+            )
+            source_que_id = _coerce_positive_int(source_field.get("que_id"))
+            if source_que_id is None:
+                source_que_id = _coerce_any_int(source_field.get("que_temp_id"))
+            if source_que_id is None:
+                raise ValueError(f"q_linker input field '{source_field.get('name')}' does not have a stable que_id")
+            key = str(input_item.get("key") or "").strip()
+            source_kind = str(input_item.get("source") or "").strip().lower()
+            compiled_inputs.append(
+                {
+                    "field": {"name": source_field.get("name"), "que_id": source_que_id},
+                    "key": key,
+                    "source": source_kind,
+                }
+            )
+            kv_item = {"key": key, "value": str(source_que_id), "type": 2}
+            if source_kind == "header":
+                compiled_headers.append(kv_item)
+            elif source_kind == "query_param":
+                compiled_query_params.append(kv_item)
+            elif source_kind == "url_encoded":
+                compiled_url_encoded.append(kv_item)
+            elif source_kind == "json_path":
+                token = "{{" + key + "}}"
+                reference = _compose_qlinker_value_reference(field_name=str(source_field.get("name") or ""), que_id=source_que_id)
+                compiled_url = compiled_url.replace(token, reference)
+                if compiled_json_value is not None:
+                    compiled_json_value = compiled_json_value.replace(token, reference)
+                if compiled_xml_value is not None:
+                    compiled_xml_value = compiled_xml_value.replace(token, reference)
+            else:
+                raise ValueError(f"q_linker_binding.inputs[{index}].source must be one of query_param, header, url_encoded, json_path")
+
+        compiled_outputs: list[dict[str, Any]] = []
+        existing_alias_by_name = {
+            str(item.get("alias_name") or ""): item
+            for item in cast(list[dict[str, Any]], current_config.get("result_format_path") or [])
+            if str(item.get("alias_name") or "")
+        }
+        for output_index, output_item in enumerate(cast(list[dict[str, Any]], binding.get("outputs") or [])):
+            target_payload = output_item.get("target_field")
+            if not isinstance(target_payload, dict):
+                raise ValueError(f"q_linker_binding.outputs[{output_index}].target_field is required")
+            target_field = _resolve_field_selector_with_uniqueness(
+                fields=next_fields,
+                selector_payload=target_payload,
+                location=f"q_linker_binding.outputs[{output_index}].target_field",
+            )
+            target_type = str(target_field.get("type") or "")
+            if not _q_linker_target_type_supported(target_type):
+                raise ValueError(f"q_linker output target field '{target_field.get('name')}' uses an unsupported field type")
+            target_ref = _coerce_positive_int(target_field.get("que_id"))
+            if target_ref is None:
+                target_ref = _coerce_any_int(target_field.get("que_temp_id"))
+            alias_name = str(output_item.get("alias") or "").strip()
+            alias_path = str(output_item.get("path") or "").strip()
+            compiled_outputs.append(
+                {
+                    "alias_name": alias_name,
+                    "alias_path": alias_path,
+                    "alias_id": _coerce_positive_int((existing_alias_by_name.get(alias_name) or {}).get("alias_id")),
+                    "target_field": {
+                        "field_id": target_field.get("field_id"),
+                        "que_id": target_ref,
+                        "name": target_field.get("name"),
+                    },
+                }
+            )
+
+        current_config.update(
+            {
+                "config_mode": 1,
+                "url": compiled_url,
+                "method": str(request.get("method") or "GET"),
+                "headers": compiled_headers,
+                "body_type": int(request.get("body_type") or 1),
+                "url_encoded_value": compiled_url_encoded,
+                "json_value": compiled_json_value,
+                "xml_value": compiled_xml_value,
+                "result_type": int(request.get("result_type") or 1),
+                "result_format_path": compiled_outputs,
+                "query_params": compiled_query_params,
+                "auto_trigger": request.get("auto_trigger"),
+                "custom_button_text_enabled": request.get("custom_button_text_enabled"),
+                "custom_button_text": request.get("custom_button_text"),
+                "being_insert_value_directly": request.get("being_insert_value_directly"),
+                "being_hide_on_form": request.get("being_hide_on_form"),
+            }
+        )
+        field["remote_lookup_config"] = current_config
+        field["_explicit_remote_lookup_config"] = False
+        field["config"] = deepcopy(current_config)
+        field["auto_trigger"] = request.get("auto_trigger")
+        field["custom_button_text_enabled"] = request.get("custom_button_text_enabled")
+        field["custom_button_text"] = request.get("custom_button_text")
+        field["q_linker_binding"] = {
+            "inputs": compiled_inputs,
+            "request": request_view,
+            "outputs": compiled_outputs,
+        }
+        source_ref = _coerce_positive_int(field.get("que_id"))
+        if source_ref is None:
+            source_ref = _coerce_any_int(field.get("que_temp_id"))
+        if source_ref is not None:
+            affected_source_refs.add(source_ref)
+        for output_item in compiled_outputs:
+            target_payload = output_item.get("target_field")
+            if not isinstance(target_payload, dict):
+                continue
+            target_field = by_name.get(str(target_payload.get("name") or ""))
+            if not isinstance(target_field, dict):
+                continue
+            target_ref = _coerce_positive_int(target_field.get("que_id"))
+            if target_ref is None:
+                target_ref = _coerce_any_int(target_field.get("que_temp_id"))
+            if target_ref is None or source_ref is None:
+                continue
+            target_field["default_type"] = DEFAULT_TYPE_RELATION
+            affected_target_refs.add(target_ref)
+            relation_specs.append(
+                {
+                    "source_field_name": field.get("name"),
+                    "source_field_ref": source_ref,
+                    "target_field_name": target_field.get("name"),
+                    "target_field_ref": target_ref,
+                    "alias": output_item.get("alias_name"),
+                }
+            )
+
+    carried_relations: list[dict[str, Any]] = []
+    for relation in existing_relations:
+        if not isinstance(relation, dict):
+            continue
+        if _coerce_positive_int(relation.get("relationType")) != RELATION_TYPE_Q_LINKER:
+            carried_relations.append(deepcopy(relation))
+            continue
+        alias_config = relation.get("aliasConfig") if isinstance(relation.get("aliasConfig"), dict) else {}
+        source_ref = _coerce_positive_int(alias_config.get("queId")) or _coerce_positive_int(relation.get("qlinkerQueId"))
+        target_ref = _coerce_positive_int(relation.get("queId"))
+        if (source_ref is not None and source_ref in affected_source_refs) or (target_ref is not None and target_ref in affected_target_refs):
+            continue
+        carried_relations.append(deepcopy(relation))
+    carried_relations.extend(_materialize_q_linker_question_relations(fields=next_fields, relation_specs=relation_specs))
+    existing_target_refs = _collect_q_linker_relation_target_refs(cast(list[dict[str, Any]], existing_relations))
+    final_target_refs = _collect_q_linker_relation_target_refs(carried_relations)
+    for field in next_fields:
+        if not isinstance(field, dict):
+            continue
+        field_ref = _coerce_positive_int(field.get("que_id"))
+        if field_ref is None:
+            field_ref = _coerce_any_int(field.get("que_temp_id"))
+        if field_ref is None or field_ref not in existing_target_refs:
+            continue
+        if field_ref in final_target_refs:
+            field["default_type"] = DEFAULT_TYPE_RELATION
+            continue
+        if _coerce_any_int(field.get("default_type")) == DEFAULT_TYPE_RELATION:
+            field["default_type"] = 1
+    return next_fields, carried_relations
+
+
+def _materialize_q_linker_question_relations(
+    fields: list[dict[str, Any]],
+    relation_specs: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    by_name = {str(field.get("name") or ""): field for field in fields if isinstance(field, dict) and str(field.get("name") or "")}
+    materialized: list[dict[str, Any]] = []
+    for relation in relation_specs:
+        if not isinstance(relation, dict):
+            continue
+        source_field = by_name.get(str(relation.get("source_field_name") or ""))
+        target_field = by_name.get(str(relation.get("target_field_name") or ""))
+        if not isinstance(source_field, dict) or not isinstance(target_field, dict):
+            continue
+        source_ref = _coerce_positive_int(source_field.get("que_id"))
+        if source_ref is None:
+            source_ref = _coerce_any_int(source_field.get("que_temp_id"))
+        if source_ref is None:
+            source_ref = _coerce_any_int(relation.get("source_field_ref"))
+        target_ref = _coerce_positive_int(target_field.get("que_id"))
+        if target_ref is None:
+            target_ref = _coerce_any_int(target_field.get("que_temp_id"))
+        if target_ref is None:
+            target_ref = _coerce_any_int(relation.get("target_field_ref"))
+        if source_ref is None or target_ref is None:
+            continue
+        materialized.append(
+            {
+                "queId": target_ref,
+                "relationType": RELATION_TYPE_Q_LINKER,
+                "displayedQueId": None,
+                "displayedQueInfo": None,
+                "qlinkerQueId": source_ref,
+                "qlinkerAlias": relation.get("alias"),
+                "aliasConfig": {
+                    "queId": source_ref,
+                    "queTitle": source_field.get("name"),
+                    "qlinkerAlias": relation.get("alias"),
+                    "aliasId": None,
+                },
+                "matchRuleType": 1,
+                "matchRules": [],
+                "matchRuleFormula": None,
+                "tableMatchRules": [],
+                "sortConfig": None,
+            }
+        )
+    return materialized
+
+
+def _collect_q_linker_relation_target_refs(relations: list[dict[str, Any]]) -> set[int]:
+    target_refs: set[int] = set()
+    for relation in relations:
+        if not isinstance(relation, dict):
+            continue
+        if _coerce_positive_int(relation.get("relationType")) != RELATION_TYPE_Q_LINKER:
+            continue
+        target_ref = _coerce_any_int(relation.get("queId"))
+        if target_ref is not None:
+            target_refs.add(target_ref)
+    return target_refs
+
+
+def _q_linker_relations_need_source_rebind(question_relations: list[dict[str, Any]]) -> bool:
+    for relation in question_relations:
+        if not isinstance(relation, dict):
+            continue
+        if _coerce_positive_int(relation.get("relationType")) != RELATION_TYPE_Q_LINKER:
+            continue
+        alias_config = relation.get("aliasConfig") if isinstance(relation.get("aliasConfig"), dict) else {}
+        source_ref = _coerce_any_int(alias_config.get("queId")) or _coerce_any_int(relation.get("qlinkerQueId"))
+        if source_ref is not None and source_ref <= 0:
+            return True
+    return False
+
+
+def _overlay_q_linker_binding_fields(*, target_fields: list[dict[str, Any]], source_fields: list[dict[str, Any]]) -> None:
+    source_by_name = {
+        str(field.get("name") or ""): field
+        for field in source_fields
+        if isinstance(field, dict) and str(field.get("name") or "")
+    }
+    for field in target_fields:
+        if not isinstance(field, dict):
+            continue
+        source = source_by_name.get(str(field.get("name") or ""))
+        if not isinstance(source, dict):
+            continue
+        if source.get("q_linker_binding") is not None:
+            binding = deepcopy(source.get("q_linker_binding"))
+            if isinstance(binding, dict):
+                for input_item in binding.get("inputs") or []:
+                    if not isinstance(input_item, dict):
+                        continue
+                    selector = input_item.get("field")
+                    if isinstance(selector, dict):
+                        selector["field_id"] = None
+                        if _coerce_positive_int(selector.get("que_id")) is None:
+                            selector["que_id"] = None
+                for output_item in binding.get("outputs") or []:
+                    if not isinstance(output_item, dict):
+                        continue
+                    selector = output_item.get("target_field")
+                    if isinstance(selector, dict):
+                        selector["field_id"] = None
+                        if _coerce_positive_int(selector.get("que_id")) is None:
+                            selector["que_id"] = None
+            field["q_linker_binding"] = binding
+
+
 def _append_field_to_layout(layout: dict[str, Any], field_name: str) -> dict[str, Any]:
     next_layout = deepcopy(layout)
     if next_layout.get("sections"):
@@ -7846,6 +9596,20 @@ def _detect_layout_mode(layout: dict[str, Any]) -> str:
     return "empty"
 
 
+def _decorate_layout_sections_as_paragraphs(sections: Any) -> list[dict[str, Any]]:
+    if not isinstance(sections, list):
+        return []
+    decorated: list[dict[str, Any]] = []
+    for section in sections:
+        if not isinstance(section, dict):
+            continue
+        payload = deepcopy(section)
+        payload["type"] = "paragraph"
+        payload["paragraph_id"] = payload.get("section_id")
+        decorated.append(payload)
+    return decorated
+
+
 def _build_verification_hints(
     *,
     tag_ids: list[int],
@@ -8160,6 +9924,13 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
     )
     if field.get("que_id"):
         question["queId"] = field["que_id"]
+    else:
+        question["queTempId"] = temp_id
+        field["que_temp_id"] = temp_id
+    if field.get("default_type") is not None:
+        question["queDefaultType"] = _coerce_positive_int(field.get("default_type")) or 1
+    if "default_value" in field:
+        question["queDefaultValue"] = field.get("default_value")
     if field.get("type") == FieldType.relation.value:
         reference = question.get("referenceConfig") if isinstance(question.get("referenceConfig"), dict) else {}
         reference["referAppKey"] = field.get("target_app_key")
@@ -8168,15 +9939,95 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
             reference["referQueId"] = field.get("target_field_que_id")
         reference["optionalDataNum"] = _relation_mode_to_optional_data_num(field.get("relation_mode"))
         question["referenceConfig"] = reference
+    if field.get("type") == FieldType.code_block.value:
+        code_block_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or {
+            "config_mode": 1,
+            "code_content": "",
+            "being_hide_on_form": False,
+            "result_alias_path": [],
+        }
+        question["codeBlockConfig"] = {
+            "configMode": code_block_config["config_mode"],
+            "codeContent": code_block_config["code_content"],
+            "resultAliasPath": [
+                _serialize_code_block_alias_path_item(item) for item in code_block_config.get("result_alias_path", [])
+            ],
+            "beingHideOnForm": code_block_config["being_hide_on_form"],
+        }
+        question["autoTrigger"] = bool(field.get("auto_trigger", False))
+        question["customBtnTextStatus"] = bool(field.get("custom_button_text_enabled", False))
+        question["customBtnText"] = str(field.get("custom_button_text") or "")
+    if field.get("type") == FieldType.q_linker.value:
+        remote_lookup_config = _normalize_remote_lookup_config(field.get("remote_lookup_config") or field.get("config") or {}) or {
+            "config_mode": 1,
+            "url": "",
+            "method": "GET",
+            "headers": [],
+            "body_type": 1,
+            "url_encoded_value": [],
+            "json_value": None,
+            "xml_value": None,
+            "result_type": 1,
+            "result_format_path": [],
+            "query_params": [],
+            "auto_trigger": None,
+            "custom_button_text_enabled": None,
+            "custom_button_text": None,
+            "being_insert_value_directly": None,
+            "being_hide_on_form": None,
+        }
+        question["remoteLookupConfig"] = {
+            "configMode": remote_lookup_config["config_mode"],
+            "url": remote_lookup_config["url"],
+            "method": remote_lookup_config["method"],
+            "headers": [_serialize_remote_lookup_key_value_item(item) for item in remote_lookup_config.get("headers", [])],
+            "bodyType": remote_lookup_config["body_type"],
+            "urlEncodedValue": [_serialize_remote_lookup_key_value_item(item) for item in remote_lookup_config.get("url_encoded_value", [])],
+            "jsonValue": remote_lookup_config.get("json_value"),
+            "xmlValue": remote_lookup_config.get("xml_value"),
+            "resultType": remote_lookup_config["result_type"],
+            "resultFormatPath": [_serialize_q_linker_alias_path_item(item) for item in remote_lookup_config.get("result_format_path", [])],
+            "queryParams": [_serialize_remote_lookup_key_value_item(item) for item in remote_lookup_config.get("query_params", [])],
+            "beingInsertValueDirectly": bool(remote_lookup_config.get("being_insert_value_directly", False)),
+            "beingHideOnForm": bool(remote_lookup_config.get("being_hide_on_form", False)),
+        }
+        if remote_lookup_config["config_mode"] == 1:
+            question["remoteLookupConfig"]["openAppConfig"] = {"event": {"eventId": 0, "name": "custom"}}
+        question["autoTrigger"] = bool(field.get("auto_trigger", remote_lookup_config.get("auto_trigger", False)))
+        question["customBtnTextStatus"] = bool(field.get("custom_button_text_enabled", remote_lookup_config.get("custom_button_text_enabled", False)))
+        question["customBtnText"] = str(field.get("custom_button_text") or remote_lookup_config.get("custom_button_text") or "")
     return question
 
 
+def _serialize_code_block_alias_path_item(value: Any) -> dict[str, Any]:
+    normalized = _normalize_code_block_alias_path_item(value) or {
+        "alias_name": "",
+        "alias_path": "",
+        "alias_type": 1,
+        "alias_id": None,
+        "sub_alias": [],
+    }
+    payload = {
+        "aliasName": normalized["alias_name"],
+        "aliasPath": normalized["alias_path"],
+        "aliasType": normalized["alias_type"],
+    }
+    if normalized.get("alias_id") is not None:
+        payload["aliasId"] = normalized["alias_id"]
+    if normalized.get("sub_alias"):
+        payload["subAlias"] = [
+            _serialize_code_block_alias_path_item(item) for item in normalized.get("sub_alias", [])
+        ]
+    return payload
+
+
 def _build_form_payload_from_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]:
     questions_by_name: dict[str, dict[str, Any]] = {}
     temp_id = -10000
@@ -8197,35 +10048,34 @@ def _build_form_payload_from_fields(
                 inner_rows.append(questions)
         if not inner_rows:
             continue
-        form_rows.append(
-            [
-                {
-                    "queId": 0,
-                    "queTempId": -(20000 + sum(ord(ch) for ch in str(section.get("section_id") or section.get("title") or "section"))),
-                    "queType": 24,
-                    "queTitle": section.get("title") or "未命名分组",
-                    "queWidth": 100,
-                    "scanType": 1,
-                    "status": 1,
-                    "required": False,
-                    "queHint": "",
-                    "linkedQuestions": {},
-                    "logicalShow": True,
-                    "queDefaultValue": None,
-                    "queDefaultType": 1,
-                    "subQueWidth": 2,
-                    "innerQuestions": inner_rows,
-                    "beingHide": False,
-                    "beingDesensitized": False,
-                    "sectionId": section.get("section_id"),
-                }
-            ]
-        )
+        wrapper = {
+            "queId": 0,
+            "queTempId": -(20000 + sum(ord(ch) for ch in str(section.get("section_id") or section.get("title") or "section"))),
+            "queType": 24,
+            "queTitle": section.get("title") or "未命名分组",
+            "queWidth": 100,
+            "scanType": 1,
+            "status": 1,
+            "required": False,
+            "queHint": "",
+            "linkedQuestions": {},
+            "logicalShow": True,
+            "queDefaultValue": None,
+            "queDefaultType": 1,
+            "subQueWidth": 2,
+            "innerQuestions": inner_rows,
+            "beingHide": False,
+            "beingDesensitized": False,
+        }
+        parsed_section_id = _coerce_positive_int(section.get("section_id"))
+        if parsed_section_id is not None:
+            wrapper["sectionId"] = parsed_section_id
+        form_rows.append([wrapper])
     for row in form_rows:
         _apply_row_widths(row)
     payload = default_form_payload(title, form_rows)
     payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
-    payload["questionRelations"] = deepcopy(current_schema.get("questionRelations") or [])
+    payload["questionRelations"] = deepcopy(question_relations if question_relations is not None else (current_schema.get("questionRelations") or []))
     return payload
 
 
@@ -9550,7 +11400,11 @@ def _build_form_payload_from_existing_schema(
             "beingDesensitized": False,
         }
         wrapper["queTitle"] = section.get("title") or wrapper.get("queTitle") or "未命名分组"
-        wrapper["sectionId"] = section.get("section_id") or wrapper.get("sectionId")
+        parsed_section_id = _coerce_positive_int(section.get("section_id"))
+        if parsed_section_id is not None:
+            wrapper["sectionId"] = parsed_section_id
+        elif _coerce_positive_int(wrapper.get("sectionId")) is None:
+            wrapper.pop("sectionId", None)
         wrapper["innerQuestions"] = inner_rows
         wrapper["queWidth"] = 100
         form_rows.append([wrapper])
@@ -9602,7 +11456,10 @@ def _select_section_template(section_templates: list[dict[str, Any]], section: d
     for template in section_templates:
         if not isinstance(template, dict):
             continue
-        if section_id and str(template.get("sectionId") or "") == section_id:
+        template_section_id = _coerce_positive_int(template.get("queId"))
+        if template_section_id is None:
+            template_section_id = _coerce_positive_int(template.get("sectionId"))
+        if section_id and template_section_id is not None and str(template_section_id) == section_id:
             return template
         if title and str(template.get("queTitle") or "") == title:
             return template