From c7cbd0b67757baf218ee2ddde178e3877b2a440f Mon Sep 17 00:00:00 2001
From: Phil Ayres <phil_ayres@hms.harvard.edu>
Date: Thu, 16 Jul 2026 20:46:35 +0100
Subject: [PATCH 1/2] Added name_starts_with_yaml_object edit field and result
 field - fixes #1269

---
 app/assets/javascripts/app/_fpa_form_utils.js |  49 ++++
 .../javascripts/app/handlebars-helpers.js     |  14 ++
 app/assets/javascripts/application.js         |   9 +
 app/assets/stylesheets/app/forms.css.scss     |   6 +
 app/assets/stylesheets/application.css        |   4 +
 .../edit_fields/edit_form_field_helper.rb     |   4 +
 app/models/dynamic/field_edit_as/handler.rb   |  49 +++-
 .../dynamic/field_edit_as/yaml_object.rb      |  37 +++
 .../_common_template_result_fields.html.erb   |  11 +
 .../_name_starts_with_yaml_object.html.erb    |  32 +++
 .../edit_form_field_helper_spec.rb            | 123 ++++++++++
 .../_fpa_form_utils_codemirror_spec.js        | 169 ++++++++++++++
 .../_handlebars_helpers_yaml_parse_spec.js    |  56 +++++
 .../dynamic/field_edit_as/handler_spec.rb     | 158 +++++++++++++
 .../dynamic/field_edit_as/yaml_object_spec.rb |  53 +++++
 spec/support/codemirror_editor_support.rb     |  18 +-
 .../dynamic_model/dynamic_model_spec.rb       |  18 +-
 .../dynamic_model_yaml_object_spec.rb         | 218 ++++++++++++++++++
 ...template_result_fields_yaml_object_spec.rb |  77 +++++++
 .../_name_starts_with_yaml_object_spec.rb     | 114 +++++++++
 20 files changed, 1201 insertions(+), 18 deletions(-)
 create mode 100644 app/models/dynamic/field_edit_as/yaml_object.rb
 create mode 100644 app/views/common_templates/edit_fields/_name_starts_with_yaml_object.html.erb
 create mode 100644 spec/javascripts/_fpa_form_utils_codemirror_spec.js
 create mode 100644 spec/javascripts/_handlebars_helpers_yaml_parse_spec.js
 create mode 100644 spec/models/dynamic/field_edit_as/handler_spec.rb
 create mode 100644 spec/models/dynamic/field_edit_as/yaml_object_spec.rb
 create mode 100644 spec/system/dynamic_model/dynamic_model_yaml_object_spec.rb
 create mode 100644 spec/views/common_templates/_common_template_result_fields_yaml_object_spec.rb
 create mode 100644 spec/views/common_templates/edit_fields/_name_starts_with_yaml_object_spec.rb

diff --git a/app/assets/javascripts/app/_fpa_form_utils.js b/app/assets/javascripts/app/_fpa_form_utils.js
index 97178ea1e3..87dde50629 100644
--- a/app/assets/javascripts/app/_fpa_form_utils.js
+++ b/app/assets/javascripts/app/_fpa_form_utils.js
@@ -138,6 +138,8 @@ _fpa.form_utils = {
   // form using the "form" attribute, indicating they belong to it. Check for this
   // and adjust the block to be formatted appropriately.
   on_form_submit: function (block) {
+    var form_block = block;
+
     if (block && block.is('form')) {
       var form_id = block.prop('id');
       if (form_id) {
@@ -148,10 +150,26 @@ _fpa.form_utils = {
       }
     }
 
+    // Synchronize CodeMirror editors to their backing textareas before submission
+    _fpa.form_utils.save_codemirror_editors(form_block);
+    if (block !== form_block) {
+      _fpa.form_utils.save_codemirror_editors(block);
+    }
+
     _fpa.form_utils.date_inputs_to_iso(block);
     _fpa.form_utils.unmask_inputs(block);
   },
 
+  // Save all CodeMirror editor instances within a block back to their backing textareas.
+  // Safely skips elements where CodeMirror was never initialized.
+  save_codemirror_editors: function (block) {
+    block.find('.code-editor').each(function () {
+      if (this.CodeMirror) {
+        this.CodeMirror.save();
+      }
+    });
+  },
+
   unmask_inputs: function (block) {
     var inputs = block.find("input[data-unmask='number'].is-masked");
     inputs
@@ -2452,6 +2470,36 @@ _fpa.form_utils = {
     _fpa.custom_editor.setup(block);
   },
 
+  // Initialize CodeMirror editors for textareas marked with class 'code-editor'
+  // (e.g. YAML/JSON edit fields - see common_templates/edit_fields/_column_type_jsonb.html.erb
+  // and _name_starts_with_yaml_object.html.erb). Without this, those fields render as plain
+  // textareas, since the main app does not otherwise load or initialize CodeMirror (unlike
+  // the admin panel - see admin/all/admin_edit_form.js#setup_codemirror_editors, which this
+  // mirrors).
+  setup_codemirror_editors: function (block) {
+    block.find('.code-editor').not('.code-editor-formatted').each(function () {
+      var code_el = $(this).get(0);
+      var mode = $(this).attr('data-code-editor-type');
+      if (!mode) mode = 'yaml';
+
+      var cm = CodeMirror.fromTextArea(code_el, {
+        lineNumbers: true,
+        mode: mode,
+        foldGutter: true,
+        gutters: ["CodeMirror-linenumbers", "CodeMirror-foldgutter"],
+        extraKeys: {
+          Tab: function (cm) { cm.execCommand("indentMore") },
+          "Shift-Tab": function (cm) { cm.execCommand("indentLess") }
+        }
+      });
+      var cme = cm.getWrapperElement();
+      cme.style.width = '100%';
+      cme.style.height = '100%';
+      code_el.CodeMirror = cm;
+      cm.refresh();
+    }).addClass('code-editor-formatted');
+  },
+
   setup_filestore: function (block) {
     block
       .find('.browse-container')
@@ -2704,6 +2752,7 @@ _fpa.form_utils = {
     _fpa.form_utils.mask_inputs(block);
     _fpa.form_utils.setup_textarea_autogrow(block);
     _fpa.form_utils.setup_textarea_editor(block);
+    _fpa.form_utils.setup_codemirror_editors(block);
     _fpa.form_utils.setup_contact_field_mask(block);
     _fpa.form_utils.setup_filestore(block);
     _fpa.form_utils.setup_e_signature(block);
diff --git a/app/assets/javascripts/app/handlebars-helpers.js b/app/assets/javascripts/app/handlebars-helpers.js
index 87dcdcd03a..1c59cfa640 100644
--- a/app/assets/javascripts/app/handlebars-helpers.js
+++ b/app/assets/javascripts/app/handlebars-helpers.js
@@ -285,6 +285,20 @@
     return typeof obj;
   });
 
+  // Parse a YAML text string into its represented Hash/Array, for fields stored as
+  // plain YAML text (see name_starts_with_yaml_object edit fields). If obj is not a
+  // string (e.g. already parsed, null, or undefined), it is returned unchanged. If the
+  // string fails to parse as YAML, it is returned unchanged so rendering degrades
+  // gracefully rather than raising.
+  Handlebars.registerHelper('yaml_parse', function (obj) {
+    if (typeof obj !== 'string') return obj;
+    try {
+      return jsyaml.load(obj);
+    } catch (e) {
+      return obj;
+    }
+  });
+
   Handlebars.registerHelper('nl2br', function (text) {
     var nl2br = _fpa.utils.nl2br(text);
     return new Handlebars.SafeString(nl2br)
diff --git a/app/assets/javascripts/application.js b/app/assets/javascripts/application.js
index 1c6e2ef9ae..209cee206d 100644
--- a/app/assets/javascripts/application.js
+++ b/app/assets/javascripts/application.js
@@ -55,4 +55,13 @@
 //= require ./big_select/big_select.js
 //= require js-yaml/dist/js-yaml 
 
+// CodeMirror - used to edit YAML content for fields such as
+// common_templates/edit_fields/_column_type_jsonb.html.erb and
+// _name_starts_with_yaml_object.html.erb (see _fpa_form_utils.js#setup_codemirror_editors)
+//= require codemirror/lib/codemirror
+//= require codemirror/addon/fold/foldcode
+//= require codemirror/addon/fold/foldgutter
+//= require codemirror/addon/fold/indent-fold
+//= require codemirror/mode/yaml/yaml
+
 //= require_tree ./app
diff --git a/app/assets/stylesheets/app/forms.css.scss b/app/assets/stylesheets/app/forms.css.scss
index f67ff4ce14..8894d4c8b5 100644
--- a/app/assets/stylesheets/app/forms.css.scss
+++ b/app/assets/stylesheets/app/forms.css.scss
@@ -28,6 +28,12 @@ form .full-width input.form-control {
   width: 100% !important;
 }
 
+// Basic visual boundary for CodeMirror editors used by YAML/JSON edit fields
+// (see _fpa_form_utils.js#setup_codemirror_editors)
+.CodeMirror.cm-s-default {
+  border: 1px solid rgb(204, 204, 204);
+}
+
 .tt-menu {
   border: 1px solid silver;
   width: 100%;
diff --git a/app/assets/stylesheets/application.css b/app/assets/stylesheets/application.css
index 8ec7808c88..728ac6d366 100644
--- a/app/assets/stylesheets/application.css
+++ b/app/assets/stylesheets/application.css
@@ -33,6 +33,10 @@
  *
  *= require ./big_select/big_select
  *
+ * CodeMirror - used to edit YAML content (see application.js and _fpa_form_utils.js)
+ *= require codemirror/lib/codemirror
+ *= require codemirror/addon/fold/foldgutter
+ *
  *= require_tree ./app
  *= require_self
  */
diff --git a/app/helpers/edit_fields/edit_form_field_helper.rb b/app/helpers/edit_fields/edit_form_field_helper.rb
index 0e44250233..2d12c495a7 100644
--- a/app/helpers/edit_fields/edit_form_field_helper.rb
+++ b/app/helpers/edit_fields/edit_form_field_helper.rb
@@ -73,6 +73,10 @@ def edit_form_field(
           match_name = "name_starts_with_#{sw}"
           next unless curr_field_name.start_with?("#{sw}_") && f_names.include?(match_name)
 
+          # yaml_object editor is only valid for text/string columns; other column types
+          # (e.g. jsonb) fall through to normal column-type rendering.
+          next if (sw == 'yaml_object') && !%i[text string].include?(column_type.to_sym)
+
           partial_fn = "common_templates/edit_fields/#{match_name}"
 
           got = render partial: partial_fn, locals: local_vars[:locals]
diff --git a/app/models/dynamic/field_edit_as/handler.rb b/app/models/dynamic/field_edit_as/handler.rb
index abbde01e9c..b5a5dc4f55 100644
--- a/app/models/dynamic/field_edit_as/handler.rb
+++ b/app/models/dynamic/field_edit_as/handler.rb
@@ -17,7 +17,11 @@ class Handler
       # the `col_type_jsonb` field type derived from jsonb columns - both are
       # handled by Dynamic::FieldEditAs::ColTypeJson, which parses the submitted
       # YAML text back into a Hash/Array for storage.
-      TransformFieldTypes = %w[multi_editable_list multi_editable_choices col_type_json].freeze
+      # `yaml_object` is resolved for name_starts_with_yaml_object fields backed by a
+      # text/varchar column (see #edit_as_field_types below) and is handled by
+      # Dynamic::FieldEditAs::YamlObject, which validates the YAML but stores the
+      # original text (since the column is text, not json/jsonb).
+      TransformFieldTypes = %w[multi_editable_list multi_editable_choices col_type_json yaml_object].freeze
 
       #
       # Initialize with the object instance to be stored to, and the params from
@@ -54,7 +58,14 @@ def translate_to_persistable
       #
       # Return a hash of field_options: <field>: edit_as: field_type: <field type value> as
       # { <field>: <field type value> }
-      # The result uses column type for those that don't have a field_type specified
+      # The result uses column type for those that don't have a field_type specified.
+      # Fields named `yaml_object_*` are resolved to the `yaml_object` field type,
+      # ONLY when the underlying column is text/varchar (the only supported backing
+      # types for yaml_object). JSON/JSONB columns continue to use their existing
+      # col_type_json/col_type_jsonb handling, and other incompatible column types
+      # (integer, boolean, etc.) fall through to their normal col_type_* behavior.
+      # Explicit yaml_object edit_as values are subject to the same column-type
+      # restriction.
       # @return [Hash]
       def edit_as_field_types
         fo = object_instance.option_type_config&.field_options || {}
@@ -63,10 +74,42 @@ def edit_as_field_types
         field_list.to_h do |fn|
           [
             fn.to_sym,
-            fo.dig(fn.to_sym, :edit_as, :field_type) || "col_type_#{cols[fn].type}"
+            field_type(fn, cols, fo)
           ]
         end
       end
+
+      #
+      # The configured field type when supported by the backing column, otherwise
+      # the column-derived default. yaml_object fields may only target text/varchar
+      # columns regardless of whether their type is inferred from the field name or
+      # explicitly configured.
+      # @param [String] field_name
+      # @param [Hash] cols - object_instance.class.columns_hash
+      # @param [Hash] field_options
+      # @return [String]
+      def field_type(field_name, cols, field_options)
+        configured_type = field_options.dig(field_name.to_sym, :edit_as, :field_type)
+        return default_field_type(field_name, cols) unless configured_type
+        return configured_type unless configured_type.include?('yaml_object')
+        return configured_type if %i[text string].include?(cols[field_name].type)
+
+        default_field_type(field_name, cols)
+      end
+
+      #
+      # The default edit_as field type for a field, derived from its name and column type.
+      # @param [String] field_name
+      # @param [Hash] cols - object_instance.class.columns_hash
+      # @return [String]
+      def default_field_type(field_name, cols)
+        col_type = cols[field_name].type
+        if field_name.start_with?('yaml_object_') && %i[text string].include?(col_type)
+          'yaml_object'
+        else
+          "col_type_#{col_type}"
+        end
+      end
     end
   end
 end
diff --git a/app/models/dynamic/field_edit_as/yaml_object.rb b/app/models/dynamic/field_edit_as/yaml_object.rb
new file mode 100644
index 0000000000..2efc3f644c
--- /dev/null
+++ b/app/models/dynamic/field_edit_as/yaml_object.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Dynamic
+  module FieldEditAs
+    #
+    # Handle validation of the YAML text edited by the user for `name_starts_with_yaml_object`
+    # fields (see views/common_templates/edit_fields/_name_starts_with_yaml_object.html.erb),
+    # for storage in a plain text/varchar database column.
+    #
+    # Unlike Dynamic::FieldEditAs::ColTypeJson (which parses the submitted YAML text into a
+    # Hash/Array for storage in a json/jsonb column), this class stores the YAML TEXT ITSELF,
+    # since the backing column here is text/varchar, not json/jsonb. Parsing here is used only
+    # to validate that the submitted text is well-formed YAML representing a Hash or Array,
+    # matching the same validation contract as ColTypeJson, before allowing it to be saved.
+    class YamlObject
+      #
+      # Get the persistable value for the provided saved_value.
+      # The incoming parameter is a YAML string submitted from the form's YAML code editor.
+      # It is validated by parsing it, but the ORIGINAL YAML TEXT is returned for storage,
+      # since the backing column is text/varchar (not json/jsonb).
+      # @param [String] saved_value - YAML text value from the param
+      # @return [String, nil] the original YAML text, once validated
+      def self.persistable_value(saved_value)
+        return unless saved_value.present?
+
+        curr_val = YAML.safe_load(saved_value)
+        unless curr_val.is_a?(Hash) || curr_val.is_a?(Array)
+          raise FphsException, "yaml_object: cannot parse saved value: (#{saved_value.class.name}) #{saved_value}"
+        end
+
+        saved_value
+      rescue Psych::Exception
+        raise FphsException, "yaml_object: cannot parse saved value: (#{saved_value.class.name}) #{saved_value}"
+      end
+    end
+  end
+end
diff --git a/app/views/common_templates/_common_template_result_fields.html.erb b/app/views/common_templates/_common_template_result_fields.html.erb
index 0900ed6046..5b1e0ae651 100644
--- a/app/views/common_templates/_common_template_result_fields.html.erb
+++ b/app/views/common_templates/_common_template_result_fields.html.erb
@@ -208,6 +208,17 @@
   {{else if (get result_data._general_selections key this_value 'name')}}
     <li class="{{> field_result_class}} is--select-field from-general-selection" data-field-name="{{key}}" data-field-type="{{field_type}}" data-field-val="{{this_value}}">{{> field_label label_resource_name=(or name_with_option_type name) replace='^select_' }} <strong>{{#if (get result_data._general_selections key this_value 'name')}}{{get result_data._general_selections key this_value 'name'}}{{else}}{{pretty_string this_value return_string="true" capitalize=false}}{{/if}}</strong></li>
 
+{{! ####### Field name starts with yaml_object_ - the stored value is plain YAML text
+      (from a text/varchar column). Parse it with the yaml_parse Handlebars helper, then
+      delegate back to this same partial with field_type cleared, reusing the existing
+      'typeof object' rendering below for the parsed Hash/Array (or falling through to
+      plain-text/null handling if parsing fails or the value is blank).
+      This must appear BEFORE all suffix-based handlers (notes, description, details,
+      etc.) so that e.g. yaml_object_notes is parsed as a YAML object rather than rendered
+      as raw text by a suffix handler. }}
+  {{else is field_type 'includes' '^yaml_object_'}}
+    {{> common_template_result_field this_value=(yaml_parse this_value) field_type=""}}
+
 {{! #######  Field ends with ... }}
   {{else is field_type 'includes' "_notes$"}}
   {{> search_results_notes_block key=key value=this_value full_name_hyphenated=(hyphenate full_name) label=name template_config=template_config }}
diff --git a/app/views/common_templates/edit_fields/_name_starts_with_yaml_object.html.erb b/app/views/common_templates/edit_fields/_name_starts_with_yaml_object.html.erb
new file mode 100644
index 0000000000..a329abf6bb
--- /dev/null
+++ b/app/views/common_templates/edit_fields/_name_starts_with_yaml_object.html.erb
@@ -0,0 +1,32 @@
+<%
+# Edit a text/varchar database column's contents as YAML text.
+#
+# DISPLAY (this template): the current column value IS the YAML text (a String, since
+# the backing column is text/varchar - NOT json/jsonb) and is shown directly in a YAML
+# codemirror editor (data-code-editor-type: 'yaml'). No hash/array conversion is
+# performed here, since the persisted value already IS the YAML text.
+#
+# SAVE: on submit, the edited YAML text arrives as a plain param string.
+# Dynamic::FieldEditAs::Handler resolves fields named "yaml_object_*" that are backed
+# by a text/varchar column (i.e. not json/jsonb) to the "yaml_object" edit_as
+# field_type, and hands the raw YAML string to
+# Dynamic::FieldEditAs::YamlObject.persistable_value, which validates that the text
+# parses as a YAML Hash/Array (raising FphsException if not) and returns the ORIGINAL
+# YAML TEXT to be persisted as-is into the text/varchar column.
+#
+# VIEW (search results): common_templates/_common_template_result_fields.html.erb
+# parses this stored YAML text back into a Hash/Array (client-side, via the
+# `yaml_parse` Handlebars helper) to render the same structured/collapsible object
+# view used for actual json/jsonb object fields.
+
+gs = form_object_instance[field_name_sym.to_s]
+options = field_options_for(form_object_instance, field_name_sym)
+
+html_options = {
+  data: { attr_name: field_name_sym, object_name: form_object_item_type_us, code_editor_type: 'yaml' },
+  class: 'code-editor code-editor-yaml',
+  value: gs
+}.merge(options)
+%>
+<%= edit_field_label(form, field_name_sym, labels, /^yaml_object_/) %>
+<%= form.text_area field_name_sym, html_options %>
diff --git a/spec/helpers/edit_fields/edit_form_field_helper_spec.rb b/spec/helpers/edit_fields/edit_form_field_helper_spec.rb
index f900cefe98..a942817965 100644
--- a/spec/helpers/edit_fields/edit_form_field_helper_spec.rb
+++ b/spec/helpers/edit_fields/edit_form_field_helper_spec.rb
@@ -13,6 +13,9 @@
 #   - Regression test for bug where Rails 7.2 capture helper HTML-escaped plain String
 #     return values from javascript_tag blocks, producing invalid <script> content
 #     (e.g. _fpa.calculate_with[&#39;field&#39;] instead of _fpa.calculate_with['field']).
+# - name_starts_with_yaml_object edit field dispatch (issue #1269).
+#   - Fields whose names begin with 'yaml_object_' must be dispatched to the
+#     _name_starts_with_yaml_object partial (YAML codemirror editor).
 
 require 'rails_helper'
 
@@ -149,4 +152,124 @@
       expect(result).to include('&quot;'), 'Expected HTML-encoded double quotes (demonstrating the bug)'
     end
   end
+
+  describe 'name_starts_with_yaml_object dispatch' do
+    let(:form_object_instance) do
+      instance_double(
+        'DynamicModel::YamlTestRecord',
+        model_data_type: :dynamic_model,
+        class: double(name: 'DynamicModel::YamlTestRecord', table_name: 'yaml_test_records'),
+        send: nil
+      )
+    end
+
+    let(:locals) { { locals: {} } }
+    let(:rendered_partials) { [] }
+
+    before do
+      allow(helper).to receive(:field_options_for).and_return({})
+      allow(helper).to receive(:is_current_admin_sample?).and_return(false)
+      allow(helper).to receive(:respond_to?).and_call_original
+      allow(helper).to receive(:general_selection_prefix_name).and_return('dynamic_model__yaml_test_records')
+      allow(Classification::GeneralSelection).to receive(:exists_for?).and_return(false)
+
+      # Reset memoized file list so the new partial is discovered
+      helper.instance_variable_set(:@f_names, nil)
+
+      allow(helper).to receive(:render) do |args|
+        partial = args[:partial]
+        rendered_partials << partial
+        "RENDERED:#{partial}"
+      end
+    end
+
+    it 'dispatches to name_starts_with_yaml_object partial for a yaml_object_ prefixed field' do
+      result = helper.edit_form_field(
+        form: double('FormBuilder'),
+        field_name_sym: :yaml_object_config,
+        field_name: 'yaml_object_config',
+        column_type: :string,
+        general_selection_name: 'dynamic_model__yaml_test_records',
+        form_object_instance: form_object_instance,
+        form_object_item_type_us: 'dynamic_model__yaml_test_records',
+        caption_before: {},
+        labels: {},
+        locals:
+      )
+
+      expect(rendered_partials).to include('common_templates/edit_fields/name_starts_with_yaml_object')
+      expect(result).to include('name_starts_with_yaml_object')
+    end
+
+    it 'does not dispatch to name_starts_with_yaml_object partial for non-yaml_object_ prefixed fields' do
+      helper.edit_form_field(
+        form: double('FormBuilder'),
+        field_name_sym: :other_config,
+        field_name: 'other_config',
+        column_type: :string,
+        general_selection_name: 'dynamic_model__yaml_test_records',
+        form_object_instance: form_object_instance,
+        form_object_item_type_us: 'dynamic_model__yaml_test_records',
+        caption_before: {},
+        labels: {},
+        locals:
+      )
+
+      expect(rendered_partials).not_to include('common_templates/edit_fields/name_starts_with_yaml_object')
+    end
+
+    it 'does not dispatch to name_starts_with_yaml_object partial for a yaml_object_ field with jsonb column type' do
+      helper.edit_form_field(
+        form: double('FormBuilder'),
+        field_name_sym: :yaml_object_config,
+        field_name: 'yaml_object_config',
+        column_type: :jsonb,
+        general_selection_name: 'dynamic_model__yaml_test_records',
+        form_object_instance: form_object_instance,
+        form_object_item_type_us: 'dynamic_model__yaml_test_records',
+        caption_before: {},
+        labels: {},
+        locals:
+      )
+
+      expect(rendered_partials).not_to include('common_templates/edit_fields/name_starts_with_yaml_object')
+      # Should fall through to column_type_jsonb partial instead
+      expect(rendered_partials).to include('common_templates/edit_fields/column_type_jsonb')
+    end
+
+    it 'does not dispatch to name_starts_with_yaml_object partial for a yaml_object_ field with json column type' do
+      helper.edit_form_field(
+        form: double('FormBuilder'),
+        field_name_sym: :yaml_object_settings,
+        field_name: 'yaml_object_settings',
+        column_type: 'json',
+        general_selection_name: 'dynamic_model__yaml_test_records',
+        form_object_instance: form_object_instance,
+        form_object_item_type_us: 'dynamic_model__yaml_test_records',
+        caption_before: {},
+        labels: {},
+        locals:
+      )
+
+      expect(rendered_partials).not_to include('common_templates/edit_fields/name_starts_with_yaml_object')
+      expect(rendered_partials).to include('common_templates/edit_fields/column_type_json')
+    end
+
+    it 'dispatches to name_starts_with_yaml_object partial when column_type is a string "string"' do
+      helper.edit_form_field(
+        form: double('FormBuilder'),
+        field_name_sym: :yaml_object_config,
+        field_name: 'yaml_object_config',
+        column_type: 'string',
+        general_selection_name: 'dynamic_model__yaml_test_records',
+        form_object_instance: form_object_instance,
+        form_object_item_type_us: 'dynamic_model__yaml_test_records',
+        caption_before: {},
+        labels: {},
+        locals:
+      )
+
+      expect(rendered_partials).to include('common_templates/edit_fields/name_starts_with_yaml_object')
+    end
+  end
 end
diff --git a/spec/javascripts/_fpa_form_utils_codemirror_spec.js b/spec/javascripts/_fpa_form_utils_codemirror_spec.js
new file mode 100644
index 0000000000..da2588b5a1
--- /dev/null
+++ b/spec/javascripts/_fpa_form_utils_codemirror_spec.js
@@ -0,0 +1,169 @@
+//= require app/_fpa_form_utils.js
+
+// _fpa.form_utils.setup_codemirror_editors spec.
+//
+// Bug: the main (non-admin) app never loaded or initialized CodeMirror, so any
+// '.code-editor' textarea (e.g. rendered by common_templates/edit_fields/_column_type_jsonb.html.erb
+// or _name_starts_with_yaml_object.html.erb) was left as a plain <textarea> instead of a
+// CodeMirror editor - unlike the admin panel, which already had its own
+// setup_codemirror_editors (see admin/all/admin_edit_form.js).
+//
+// Tests verify:
+// - A '.code-editor' textarea is converted into a real CodeMirror instance.
+// - The textarea's initial value is preserved in the CodeMirror editor.
+// - The mode defaults to 'yaml' when no data-code-editor-type attribute is present.
+// - The data-code-editor-type attribute is honoured when present.
+// - Elements are not re-initialized (marked 'code-editor-formatted' and skipped on repeat calls).
+// - This is wired into _fpa.form_utils.format_block, the central per-block form setup entry point.
+describe('_fpa.form_utils.setup_codemirror_editors', function () {
+  var container;
+
+  beforeEach(function () {
+    container = $([
+      '<div id="codemirror-test-container">',
+      '  <textarea class="code-editor code-editor-yaml" data-code-editor-type="yaml">key1: value1</textarea>',
+      '</div>'
+    ].join('\n'));
+    $('body').append(container);
+  });
+
+  afterEach(function () {
+    container.remove();
+  });
+
+  it('converts a .code-editor textarea into a real CodeMirror instance', function () {
+    _fpa.form_utils.setup_codemirror_editors(container);
+
+    var codeEl = container.find('.code-editor').get(0);
+    expect(codeEl.CodeMirror).toBeDefined();
+    expect(typeof codeEl.CodeMirror.getValue).toEqual('function');
+  });
+
+  it('preserves the textarea initial value in the CodeMirror editor', function () {
+    _fpa.form_utils.setup_codemirror_editors(container);
+
+    var codeEl = container.find('.code-editor').get(0);
+    expect(codeEl.CodeMirror.getValue()).toEqual('key1: value1');
+  });
+
+  it('defaults the mode to yaml when data-code-editor-type is not present', function () {
+    container.find('.code-editor').removeAttr('data-code-editor-type');
+
+    _fpa.form_utils.setup_codemirror_editors(container);
+
+    var codeEl = container.find('.code-editor').get(0);
+    expect(codeEl.CodeMirror.getOption('mode')).toEqual('yaml');
+  });
+
+  it('marks the element as code-editor-formatted so it is not re-initialized', function () {
+    _fpa.form_utils.setup_codemirror_editors(container);
+
+    var firstInstance = container.find('.code-editor').get(0).CodeMirror;
+
+    // Call again - should be a no-op for the already-formatted element
+    _fpa.form_utils.setup_codemirror_editors(container);
+
+    var secondInstance = container.find('.code-editor').get(0).CodeMirror;
+    expect(secondInstance).toBe(firstInstance);
+  });
+
+  it('is invoked as part of format_block so newly-loaded forms get their editors initialized', function () {
+    spyOn(_fpa.form_utils, 'setup_codemirror_editors').and.callThrough();
+
+    _fpa.form_utils.format_block(container);
+
+    expect(_fpa.form_utils.setup_codemirror_editors).toHaveBeenCalled();
+  });
+});
+
+// _fpa.form_utils.on_form_submit CodeMirror save regression spec.
+//
+// Bug: CodeMirror editors in the main app were initialized correctly, but their
+// values were never saved back to the backing textarea on form submit, causing
+// stale (empty or original) values to be submitted instead of user edits.
+//
+// Tests verify:
+// - on_form_submit calls save() on initialized CodeMirror editors within the form block.
+// - Editors without a CodeMirror instance (plain textareas with .code-editor class) are
+//   safely ignored without errors.
+// - Report-edit forms with external form-associated inputs still have their in-form
+//   editors saved.
+describe('_fpa.form_utils.on_form_submit CodeMirror save', function () {
+  var container;
+
+  afterEach(function () {
+    if (container) container.remove();
+  });
+
+  it('calls save() on initialized CodeMirror editors before date/mask conversion', function () {
+    container = $([
+      '<form id="test-submit-form">',
+      '  <textarea class="code-editor">original</textarea>',
+      '  <input type="text" class="date-is-local" value="">',
+      '</form>'
+    ].join('\n'));
+    $('body').append(container);
+
+    // Initialize CodeMirror on the textarea
+    _fpa.form_utils.setup_codemirror_editors(container);
+
+    var codeEl = container.find('.code-editor').get(0);
+    // Simulate user editing in CodeMirror (value diverges from textarea)
+    codeEl.CodeMirror.setValue('edited: value');
+
+    // Textarea still has the old value before save
+    expect($(codeEl).val()).toEqual('original');
+
+    // Trigger form submit handling
+    _fpa.form_utils.on_form_submit(container);
+
+    // After on_form_submit, textarea should have the CodeMirror content
+    expect($(codeEl).val()).toEqual('edited: value');
+  });
+
+  it('safely ignores a .code-editor element without a CodeMirror instance', function () {
+    container = $([
+      '<form id="test-no-cm-form">',
+      '  <textarea class="code-editor">plain text</textarea>',
+      '</form>'
+    ].join('\n'));
+    $('body').append(container);
+
+    // Do NOT initialize CodeMirror - simulates a scenario where setup was skipped
+
+    // Should not throw
+    expect(function () {
+      _fpa.form_utils.on_form_submit(container);
+    }).not.toThrow();
+  });
+
+  it('saves editors in the original form block even when block is reassigned for report-edit', function () {
+    // Simulate report-edit: form has an id, and external inputs reference it
+    container = $([
+      '<div id="report-edit-wrapper">',
+      '  <form id="report-edit-form">',
+      '    <textarea class="code-editor">report yaml</textarea>',
+      '  </form>',
+      '  <div id="external-inputs">',
+      '    <input form="report-edit-form" type="text" value="ext">',
+      '  </div>',
+      '</div>'
+    ].join('\n'));
+    $('body').append(container);
+
+    var form = container.find('form');
+    _fpa.form_utils.setup_codemirror_editors(form);
+
+    var codeEl = form.find('.code-editor').get(0);
+    codeEl.CodeMirror.setValue('updated: content');
+
+    // Textarea still has old value
+    expect($(codeEl).val()).toEqual('report yaml');
+
+    // on_form_submit will reassign block to external inputs parent,
+    // but should still save the form's CodeMirror editors
+    _fpa.form_utils.on_form_submit(form);
+
+    expect($(codeEl).val()).toEqual('updated: content');
+  });
+});
diff --git a/spec/javascripts/_handlebars_helpers_yaml_parse_spec.js b/spec/javascripts/_handlebars_helpers_yaml_parse_spec.js
new file mode 100644
index 0000000000..c43d1e0db3
--- /dev/null
+++ b/spec/javascripts/_handlebars_helpers_yaml_parse_spec.js
@@ -0,0 +1,56 @@
+//= require js-yaml/dist/js-yaml
+//= require app/handlebars-helpers.js
+
+// yaml_parse Handlebars helper spec (issue #1269).
+//
+// The yaml_parse helper parses a YAML text string into its represented Hash/Array,
+// used to display name_starts_with_yaml_object fields (stored as plain YAML text in a
+// text/varchar column) as a structured object view in search results.
+//
+// Tests verify:
+// - A YAML string representing a Hash is parsed into an object with accessible keys.
+// - A YAML string representing an Array is parsed into an iterable array.
+// - Non-string input (already an object, null, undefined) is returned unchanged.
+// - Malformed YAML text is returned unchanged (safe fallback) rather than raising.
+describe('yaml_parse Handlebars helper', function () {
+  it('parses a YAML hash string into an object usable with Handlebars property access', function () {
+    var template = Handlebars.compile('{{#with (yaml_parse yaml_text)}}{{key1}}/{{key2}}{{/with}}');
+
+    var result = template({ yaml_text: 'key1: value1\nkey2: 42\n' });
+
+    expect(result).toEqual('value1/42');
+  });
+
+  it('parses a YAML array string into an iterable array', function () {
+    var template = Handlebars.compile('{{#each (yaml_parse yaml_text)}}[{{this}}]{{/each}}');
+
+    var result = template({ yaml_text: '- first\n- second\n' });
+
+    expect(result).toEqual('[first][second]');
+  });
+
+  it('returns non-string input unchanged', function () {
+    var template = Handlebars.compile('{{#with (yaml_parse obj)}}{{key1}}{{/with}}');
+
+    var result = template({ obj: { key1: 'already an object' } });
+
+    expect(result).toEqual('already an object');
+  });
+
+  it('returns null/undefined input unchanged without raising', function () {
+    var template = Handlebars.compile('[{{yaml_parse missing}}]');
+
+    var result = template({});
+
+    expect(result).toEqual('[]');
+  });
+
+  it('returns malformed YAML text unchanged rather than raising', function () {
+    var template = Handlebars.compile('{{yaml_parse yaml_text}}');
+    var malformed = 'key1: [1, 2';
+
+    var result = template({ yaml_text: malformed });
+
+    expect(result).toEqual(malformed);
+  });
+});
diff --git a/spec/models/dynamic/field_edit_as/handler_spec.rb b/spec/models/dynamic/field_edit_as/handler_spec.rb
new file mode 100644
index 0000000000..ec0363cb04
--- /dev/null
+++ b/spec/models/dynamic/field_edit_as/handler_spec.rb
@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+# Spec for Dynamic::FieldEditAs::Handler (issue #1269).
+#
+# Covers the routing logic in #edit_as_field_types / #translate_to_persistable for
+# name_starts_with_yaml_object fields:
+# - A field named `yaml_object_*` backed by a text/varchar column routes to
+#   Dynamic::FieldEditAs::YamlObject (stores validated YAML text as-is).
+# - A field named `yaml_object_*` backed by a json/jsonb column (unsupported/legacy
+#   configuration) still routes to Dynamic::FieldEditAs::ColTypeJson, preserving prior
+#   behavior as a safety net.
+# - A field named `yaml_object_*` backed by an incompatible column type (integer,
+#   boolean, etc.) does NOT get the yaml_object transform - the field is treated
+#   normally by its column type.
+# - An explicit field_options edit_as: field_type: configuration takes precedence over
+#   the name-based default in both cases.
+# - Fields not matching `yaml_object_*` continue to resolve by column type as before.
+
+RSpec.describe Dynamic::FieldEditAs::Handler do
+  def build_object_instance(attribute_names:, column_types:, field_options: {})
+    columns_hash = column_types.transform_values { |type| double('Column', type: type) }
+
+    instance_double(
+      'UserBase',
+      option_type_config: double('OptionTypeConfig', field_options: field_options),
+      class: double('Klass', columns_hash: columns_hash),
+      attribute_names: attribute_names
+    )
+  end
+
+  describe '#translate_to_persistable' do
+    it 'routes a yaml_object_* field on a text column to YamlObject and stores the YAML text as-is' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_config],
+        column_types: { 'yaml_object_config' => :text }
+      )
+      yaml_text = "key1: value1\n"
+      params = { yaml_object_config: yaml_text }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq(yaml_object_config: yaml_text)
+    end
+
+    it 'routes a yaml_object_* field on a string column to YamlObject' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_config],
+        column_types: { 'yaml_object_config' => :string }
+      )
+      yaml_text = "- first\n- second\n"
+      params = { yaml_object_config: yaml_text }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq(yaml_object_config: yaml_text)
+    end
+
+    it 'raises FphsException via YamlObject when the submitted YAML is malformed' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_config],
+        column_types: { 'yaml_object_config' => :text }
+      )
+      params = { yaml_object_config: 'key1: [1, 2' }
+
+      handler = described_class.new(object_instance, params)
+
+      expect { handler.translate_to_persistable }.to raise_error(FphsException, /cannot parse saved value/)
+    end
+
+    it 'routes a yaml_object_* field on a jsonb column to ColTypeJson (legacy/safety-net behavior)' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_config],
+        column_types: { 'yaml_object_config' => :jsonb }
+      )
+      params = { yaml_object_config: "key1: value1\n" }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq(yaml_object_config: { 'key1' => 'value1' })
+    end
+
+    it 'routes a yaml_object_* field on a json column to ColTypeJson (legacy/safety-net behavior)' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_config],
+        column_types: { 'yaml_object_config' => :json }
+      )
+      params = { yaml_object_config: "- first\n- second\n" }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq(yaml_object_config: %w[first second])
+    end
+
+    it 'gives precedence to an explicit edit_as field_type over the yaml_object_ name default' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_config],
+        column_types: { 'yaml_object_config' => :text },
+        field_options: { yaml_object_config: { edit_as: { field_type: 'multi_editable_list' } } }
+      )
+      params = { yaml_object_config: "line1\nline2" }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq(yaml_object_config: %w[line1 line2])
+    end
+
+    it 'does not apply an explicit yaml_object transform to an unsupported column type' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_count],
+        column_types: { 'yaml_object_count' => :integer },
+        field_options: { yaml_object_count: { edit_as: { field_type: 'yaml_object' } } }
+      )
+      params = { yaml_object_count: "key1: value1\n" }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq({})
+    end
+
+    it 'does not apply yaml_object transform to a yaml_object_* field on an integer column' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_count],
+        column_types: { 'yaml_object_count' => :integer }
+      )
+      params = { yaml_object_count: '42' }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq({})
+    end
+
+    it 'does not apply yaml_object transform to a yaml_object_* field on a boolean column' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_flag],
+        column_types: { 'yaml_object_flag' => :boolean }
+      )
+      params = { yaml_object_flag: 'true' }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq({})
+    end
+
+    it 'does not affect fields that do not start with yaml_object_' do
+      object_instance = build_object_instance(
+        attribute_names: %w[plain_config],
+        column_types: { 'plain_config' => :string }
+      )
+      params = { plain_config: 'some text' }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq({})
+    end
+  end
+end
diff --git a/spec/models/dynamic/field_edit_as/yaml_object_spec.rb b/spec/models/dynamic/field_edit_as/yaml_object_spec.rb
new file mode 100644
index 0000000000..5c19d92fc1
--- /dev/null
+++ b/spec/models/dynamic/field_edit_as/yaml_object_spec.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+# Spec for Dynamic::FieldEditAs::YamlObject (issue #1269).
+#
+# This class validates YAML text submitted from the name_starts_with_yaml_object edit
+# field for storage in a plain text/varchar database column. Unlike ColTypeJson (used for
+# json/jsonb columns), it does NOT parse the value into a Hash/Array for storage - it
+# validates the YAML and returns the ORIGINAL TEXT, since the backing column is text.
+#
+# Tests verify:
+# - Valid YAML representing a Hash is returned unchanged (as text).
+# - Valid YAML representing an Array is returned unchanged (as text).
+# - Blank/nil input returns nil.
+# - Malformed YAML raises FphsException.
+# - YAML that parses to a scalar (not Hash/Array) raises FphsException.
+
+RSpec.describe Dynamic::FieldEditAs::YamlObject do
+  describe '.persistable_value' do
+    it 'returns the original YAML text unchanged when it represents a Hash' do
+      yaml_text = "key1: value1\nkey2: 42\n"
+
+      expect(described_class.persistable_value(yaml_text)).to eq(yaml_text)
+    end
+
+    it 'returns the original YAML text unchanged when it represents an Array' do
+      yaml_text = "- first\n- second\n"
+
+      expect(described_class.persistable_value(yaml_text)).to eq(yaml_text)
+    end
+
+    it 'returns nil for a blank value' do
+      expect(described_class.persistable_value('')).to be_nil
+    end
+
+    it 'returns nil for a nil value' do
+      expect(described_class.persistable_value(nil)).to be_nil
+    end
+
+    it 'raises FphsException for malformed YAML' do
+      malformed = "key1: [1, 2\n"
+
+      expect { described_class.persistable_value(malformed) }.to raise_error(FphsException, /cannot parse saved value/)
+    end
+
+    it 'raises FphsException when the YAML parses to a scalar rather than a Hash/Array' do
+      scalar_yaml = 'just a plain string'
+
+      expect { described_class.persistable_value(scalar_yaml) }.to raise_error(FphsException, /cannot parse saved value/)
+    end
+  end
+end
diff --git a/spec/support/codemirror_editor_support.rb b/spec/support/codemirror_editor_support.rb
index e5b56ac5a5..2d55fbc298 100644
--- a/spec/support/codemirror_editor_support.rb
+++ b/spec/support/codemirror_editor_support.rb
@@ -11,7 +11,7 @@
 #   content = codemirror_get_value(form_id: 'edit_dynamic_model_123')
 #
 #   # Set editor content
-#   codemirror_set_value(form_id: 'edit_dynamic_model_123', value: 'new content')
+#   codemirror_set_value(form_id: 'edit_dynamic_model_123', field_name: 'config', value: 'new content')
 #
 #   # Prepend text
 #   codemirror_prepend(form_id: 'edit_dynamic_model_123', text: "# Header\n")
@@ -38,16 +38,22 @@ def codemirror_get_value(form_id:)
 
   # Set the value in a CodeMirror editor
   # @param form_id [String] The ID of the form containing the editor
+  # @param field_name [String, nil] The data-attr-name of a specific editor in the form
   # @param value [String] The new content to set
   # @param sync [Boolean] Whether to sync to the underlying textarea (default: true)
-  def codemirror_set_value(form_id:, value:, sync: true)
+  def codemirror_set_value(form_id:, value:, field_name: nil, sync: true)
     escaped_value = value.gsub('\\', '\\\\\\\\').gsub("\n", '\\n').gsub("'", "\\\\'")
+    editor_selector = if field_name
+                        "textarea.code-editor[data-attr-name='#{field_name}']"
+                      else
+                        'textarea.code-editor'
+                      end
     page.execute_script(<<~JS)
       var form = document.getElementById('#{form_id}');
-      var editor = form ? form.querySelector('textarea.code-editor') : null;
+      var editor = form ? form.querySelector("#{editor_selector}") : null;
       if (editor && editor.CodeMirror) {
         editor.CodeMirror.setValue('#{escaped_value}');
-        #{sync ? 'editor.CodeMirror.save();' : ''}
+        #{'editor.CodeMirror.save();' if sync}
       }
     JS
   end
@@ -64,7 +70,7 @@ def codemirror_prepend(form_id:, text:, sync: false)
       if (editor && editor.CodeMirror) {
         var currentValue = editor.CodeMirror.getValue();
         editor.CodeMirror.setValue('#{escaped_text}' + currentValue);
-        #{sync ? 'editor.CodeMirror.save();' : ''}
+        #{'editor.CodeMirror.save();' if sync}
       }
     JS
   end
@@ -84,7 +90,7 @@ def codemirror_replace(form_id:, pattern:, replacement:, flags: 'gm', sync: true
         var currentValue = editor.CodeMirror.getValue();
         var fixedValue = currentValue.replace(/#{pattern}/#{flags}, '#{escaped_replacement}');
         editor.CodeMirror.setValue(fixedValue);
-        #{sync ? 'editor.CodeMirror.save();' : ''}
+        #{'editor.CodeMirror.save();' if sync}
       }
     JS
   end
diff --git a/spec/system/dynamic_model/dynamic_model_spec.rb b/spec/system/dynamic_model/dynamic_model_spec.rb
index b09d45abe8..385413d7de 100644
--- a/spec/system/dynamic_model/dynamic_model_spec.rb
+++ b/spec/system/dynamic_model/dynamic_model_spec.rb
@@ -85,7 +85,7 @@ def set_up_feature
 
       b.click
       expect(page).to have_css('form.new_dynamic_model_test_all_v2_field', wait: 10)
-      new_num = rand(100_000_000..999_999_999)
+      rand(100_000_000..999_999_999)
       within('form.new_dynamic_model_test_all_v2_field') do
         sleep 2
         # Basic string fields
@@ -109,8 +109,8 @@ def set_up_feature
         check 'A boolean'
 
         # JSON/JSONB fields
-        fill_in 'Json', with: '{"key": "value"}'
-        fill_in 'Jsonb', with: '{"name": "Test", "active": true}'
+        codemirror_set_value(form_id: 'new_dynamic_model_test_all_v2_field', field_name: 'json', value: '{"key": "value"}')
+        codemirror_set_value(form_id: 'new_dynamic_model_test_all_v2_field', field_name: 'jsonb', value: '{"name": "Test", "active": true}')
 
         # Classification fields
         select 'General', from: 'Protocol'
@@ -143,12 +143,12 @@ def set_up_feature
         select 'True', from: 'Done true false' if page.has_select?('Done true false')
 
         # Text area fields
-        fill_in 'Some description', with: 'This is a detailed description with multiple lines.\nSecond line of description.'
-        fill_in 'Some details', with: 'These are some details about the record.'
-        fill_in 'Some notes', with: 'Important notes about this record.'
-        fill_in 'Description', with: 'Another description field value.'
-        fill_in 'Notes', with: 'Additional notes.'
-        fill_in 'Message', with: 'A message for this record.'
+        edit_rich_text_editor_field('some_description', 'This is a detailed description for the record.')
+        edit_rich_text_editor_field('some_details', 'These are some details about the record.')
+        edit_rich_text_editor_field('some_notes', 'Important notes about this record.')
+        edit_rich_text_editor_field('description', 'Another description field value.')
+        edit_rich_text_editor_field('notes', 'Additional notes.')
+        edit_rich_text_editor_field('message', 'A message for this record.')
 
         # URL and link fields
         fill_in 'A link', with: 'https://example.com/link'
diff --git a/spec/system/dynamic_model/dynamic_model_yaml_object_spec.rb b/spec/system/dynamic_model/dynamic_model_yaml_object_spec.rb
new file mode 100644
index 0000000000..28b3e5bafb
--- /dev/null
+++ b/spec/system/dynamic_model/dynamic_model_yaml_object_spec.rb
@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+# System spec for GitHub issue #1269 - yaml_object field workflow.
+#
+# Purpose: verify end-to-end behavior of a dynamic model field named `yaml_object_*`
+# backed by a text/varchar column:
+# 1. The edit form renders a YAML CodeMirror editor (code-editor-yaml class).
+# 2. Valid YAML Hash/Array text can be submitted and persists as raw YAML text.
+# 3. After save, the show view renders the parsed YAML as a structured object
+#    (via the yaml_parse Handlebars helper and the 'typeof object' template path).
+# 4. Edit mode re-opens the CodeMirror editor pre-filled with the persisted YAML text.
+#
+# The spec creates a minimal dynamic model with a yaml_object_config text field,
+# exercises create/edit via the CodeMirror helper, and verifies persistence and display.
+
+require 'rails_helper'
+
+describe 'dynamic model yaml_object field', js: true, driver: $browser_driver do
+  include ModelSupport
+  include MasterDataSupport
+  include FeatureSupport
+  include DynamicModelSupport
+  include DynamicModelExpectationsSupport
+  include CodemirrorEditorSupport
+
+  def set_up_feature
+    SetupHelper.feature_setup
+    change_setting('TwoFactorAuthDisabledForUser', true)
+    change_setting('AllowDynamicMigrations', true)
+
+    create_admin
+
+    ms = Master.no_temporary_masters
+    if ms.none? || ms.first.nil? || ms.first.id < 1
+      create_data_set_outside_tx
+      @master ||= ms.first
+      @master_id ||= @master.id
+    else
+      @master = ms.first
+      @master_id = @master.id
+    end
+
+    expect(@master_id).to be > 0
+
+    @user, @good_password = create_user(create_master: true)
+    @good_email = @user.email
+    @app_type = @user.app_type
+    expect(@app_type).not_to be nil
+    expect(@user.two_factor_setup_required?).to be_falsey
+  end
+
+  def setup_yaml_object_dm
+    DynamicModel.active.where(table_name: 'test_yaml_object_fields').reload.each { |dm| dm.disable!(@admin) }
+    DynamicModel.send(:remove_const, :TestYamlObjectField) if defined? DynamicModel::TestYamlObjectField
+
+    dm_options = <<~YAML
+      _configurations: {}
+
+      default:
+        labels:
+          yaml_object_config: Config
+          title: Title
+    YAML
+
+    dm = DynamicModel.create! current_admin: @admin,
+                              name: 'test yaml object fields',
+                              schema_name: 'dynamic_test',
+                              table_name: 'test_yaml_object_fields',
+                              category: :details,
+                              options: dm_options,
+                              field_list: 'title yaml_object_config',
+                              primary_key_name: 'id',
+                              foreign_key_name: 'master_id'
+
+    dm.current_admin = @admin
+    dm.update_tracker_events
+
+    setup_access :dynamic_model__test_yaml_object_fields, user: @user
+
+    dm
+  end
+
+  describe 'create and edit with yaml_object field' do
+    before(:all) do
+      set_up_feature
+      @yaml_dm = setup_yaml_object_dm
+
+      @yaml_dm.force_regenerate = true
+      @yaml_dm.generate_model
+      @yaml_dm.add_master_association
+
+      DynamicModel.routes_load
+      Rails.application.routes_reloader.reload!
+    end
+
+    before(:each) do
+      validate_setup
+      login
+    end
+
+    it 'creates a record with valid YAML in a CodeMirror editor and persists raw text' do
+      yaml_text = "name: test\nitems:\n  - one\n  - two"
+
+      visit "/masters/search?utf8=%E2%9C%93&nav_q_id=#{@master.id}"
+      dismiss_modal
+      finish_page_loading
+
+      expect(page).to have_css("#master-#{@master.id}")
+
+      expand_master_record_tab('details')
+      finish_page_loading
+
+      new_button_selector = '.details-item-type-dynamic-model--test-yaml-object-fields .new-button-container a.btn'
+      expect(page).to have_css(new_button_selector, wait: 10)
+
+      new_button = find(new_button_selector, wait: 10)
+      scroll_into_view(new_button)
+      new_button.click
+      finish_page_loading
+
+      form_selector = 'form.new_dynamic_model_test_yaml_object_field'
+      expect(page).to have_css(form_selector, wait: 10)
+      finish_form_formatting
+      sleep 1
+
+      # Verify the CodeMirror YAML editor is rendered
+      within(form_selector) do
+        expect(page).to have_css('textarea.code-editor-yaml[data-code-editor-type="yaml"]', visible: :all)
+        fill_in 'Title', with: 'yaml test record'
+      end
+
+      # Set YAML content via the CodeMirror helper
+      form_id = find(form_selector)[:id]
+      codemirror_set_value(form_id: form_id, field_name: 'yaml_object_config', value: yaml_text)
+
+      within(form_selector) do
+        click_on 'Save'
+      end
+
+      finish_page_loading
+
+      # Verify the record persisted the raw YAML text in the database
+      record = DynamicModel::TestYamlObjectField.last
+      expect(record).not_to be_nil
+      # Browser textareas submit CRLF; normalize before comparing
+      expect(record.yaml_object_config.gsub("\r\n", "\n")).to eq(yaml_text)
+      expect(record.title).to eq('yaml test record')
+
+      # Verify the show view renders the parsed YAML as a structured object
+      # The yaml_parse helper converts the text to an object, then the 'typeof object'
+      # branch renders it with the .typeof-object-field class
+      show_selector = ".common-templates--result-item[data-item-class='dynamic_model__test_yaml_object_field']"
+      expect(page).to have_css(show_selector, wait: 10)
+
+      within(show_selector) do
+        expect(page).to have_css('li.typeof-object-field[data-field-name="yaml_object_config"]', wait: 10)
+      end
+    end
+
+    it 'edits an existing record and updates the YAML content' do
+      # Create a record directly for editing
+      @master.current_user = @user
+      initial_yaml = 'key: initial_value'
+      record = DynamicModel::TestYamlObjectField.create!(
+        current_user: @user,
+        master: @master,
+        title: 'edit test',
+        yaml_object_config: initial_yaml
+      )
+
+      visit "/masters/search?utf8=%E2%9C%93&nav_q_id=#{@master.id}"
+      dismiss_modal
+      finish_page_loading
+
+      expect(page).to have_css("#master-#{@master.id}")
+
+      expand_master_record_tab('details')
+      finish_page_loading
+
+      # Find the show view for the record and click edit
+      show_selector = ".common-templates--result-item[data-item-class='dynamic_model__test_yaml_object_field']"
+      expect(page).to have_css(show_selector, wait: 10)
+
+      click_edit_button_in(show_selector)
+
+      edit_form_selector = 'form.edit_dynamic_model_test_yaml_object_field'
+      expect(page).to have_css(edit_form_selector, wait: 10)
+      finish_form_formatting
+      sleep 1
+
+      # Verify the CodeMirror editor has the existing YAML content
+      form_id = find(edit_form_selector)[:id]
+      editor_content = codemirror_get_value(form_id: form_id)
+      expect(editor_content).to eq(initial_yaml)
+
+      # Update with new YAML content
+      updated_yaml = "key: updated_value\nnew_key: added"
+      codemirror_set_value(form_id: form_id, field_name: 'yaml_object_config', value: updated_yaml)
+
+      within(edit_form_selector) do
+        click_on 'Save'
+      end
+
+      finish_page_loading
+
+      # Verify persistence of the updated value
+      record.reload
+      # Browser textareas submit CRLF; normalize before comparing
+      expect(record.yaml_object_config.gsub("\r\n", "\n")).to eq(updated_yaml)
+
+      # Verify the updated structured display
+      expect(page).to have_css(show_selector, wait: 10)
+      within(show_selector) do
+        expect(page).to have_css('li.typeof-object-field[data-field-name="yaml_object_config"]', wait: 10)
+      end
+    end
+  end
+end
diff --git a/spec/views/common_templates/_common_template_result_fields_yaml_object_spec.rb b/spec/views/common_templates/_common_template_result_fields_yaml_object_spec.rb
new file mode 100644
index 0000000000..9c6bd565b4
--- /dev/null
+++ b/spec/views/common_templates/_common_template_result_fields_yaml_object_spec.rb
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+# Spec for the yaml_object_ result field Handlebars condition in
+# common_templates/_common_template_result_fields.html.erb (issue #1269).
+#
+# yaml_object_* fields are backed by a text/varchar column, so the stored `this_value`
+# arrives as plain YAML text (a String), not an already-parsed Hash/Array. The Handlebars
+# condition for these fields must parse that text (via the `yaml_parse` helper - see
+# handlebars-helpers.js) and then reuse the existing structured/collapsible object view
+# used for real json/jsonb object fields (the 'typeof object' branch), rather than
+# duplicating that rendering markup.
+#
+# Tests verify:
+# - The template source contains the '^yaml_object_' Handlebars field_type condition.
+# - The yaml_object_ condition appears BEFORE the generic 'typeof' 'object' condition,
+#   so it takes precedence for fields with that name prefix.
+# - The yaml_object_ condition appears BEFORE all suffix-based handlers (_notes$,
+#   _description$, _details$), so e.g. yaml_object_notes is parsed as YAML rather than
+#   rendered as raw text by a suffix handler.
+# - The yaml_object_ condition parses this_value via the yaml_parse helper.
+# - The yaml_object_ condition delegates to the same partial (common_template_result_field)
+#   with field_type cleared, so the recursive call cannot re-match '^yaml_object_' (avoiding
+#   infinite recursion) and instead falls through to the 'typeof object' rendering.
+
+RSpec.describe 'common_templates result fields yaml_object_ condition', type: :view do
+  let(:template_path) do
+    Rails.root.join('app', 'views', 'common_templates', '_common_template_result_fields.html.erb')
+  end
+
+  let(:template_source) { File.read(template_path) }
+
+  it 'contains a Handlebars condition matching field_type starting with yaml_object_' do
+    expect(template_source).to match(/\^yaml_object_/)
+  end
+
+  it 'places the yaml_object_ condition before the typeof object condition' do
+    yaml_object_pos = template_source.index(/\^yaml_object_/)
+    typeof_object_pos = template_source.index("'typeof' 'object'")
+
+    expect(yaml_object_pos).to be < typeof_object_pos,
+                               'yaml_object_ condition must appear before the typeof object condition'
+  end
+
+  it 'places the yaml_object_ condition before all suffix-based handlers (_notes, _description, _details)' do
+    yaml_object_pos = template_source.index(/\^yaml_object_/)
+    notes_pos = template_source.index('"_notes$"')
+    description_pos = template_source.index('"_description$"')
+    details_pos = template_source.index('"_details$"')
+
+    expect(yaml_object_pos).to be < notes_pos,
+                               'yaml_object_ condition must appear before the _notes$ suffix handler'
+    expect(yaml_object_pos).to be < description_pos,
+                               'yaml_object_ condition must appear before the _description$ suffix handler'
+    expect(yaml_object_pos).to be < details_pos,
+                               'yaml_object_ condition must appear before the _details$ suffix handler'
+  end
+
+  it 'parses this_value via the yaml_parse helper within the yaml_object_ condition block' do
+    yaml_object_pos = template_source.index(/\^yaml_object_/)
+    window = template_source[yaml_object_pos, 400]
+
+    expect(window).to include('(yaml_parse this_value)'),
+                      'yaml_object_ block must parse this_value with the yaml_parse helper'
+  end
+
+  it 'delegates to common_template_result_field with field_type cleared to avoid infinite recursion' do
+    yaml_object_pos = template_source.index(/\^yaml_object_/)
+    window = template_source[yaml_object_pos, 400]
+
+    expect(window).to include('common_template_result_field'),
+                      'yaml_object_ block must delegate to the common_template_result_field partial'
+    expect(window).to include('field_type=""'),
+                      'yaml_object_ block must clear field_type on the recursive call to avoid infinite recursion'
+  end
+end
diff --git a/spec/views/common_templates/edit_fields/_name_starts_with_yaml_object_spec.rb b/spec/views/common_templates/edit_fields/_name_starts_with_yaml_object_spec.rb
new file mode 100644
index 0000000000..d464443cce
--- /dev/null
+++ b/spec/views/common_templates/edit_fields/_name_starts_with_yaml_object_spec.rb
@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+# View spec for common_templates/edit_fields/_name_starts_with_yaml_object partial (issue #1269).
+#
+# This partial provides a YAML codemirror editor for fields whose names begin with
+# 'yaml_object_'. The field is backed ONLY by a text/varchar database column - the
+# stored value IS the YAML text, so it is displayed directly with no hash/array conversion.
+# On save, Dynamic::FieldEditAs::Handler routes yaml_object_* fields (on non-json/jsonb
+# columns) to Dynamic::FieldEditAs::YamlObject, which validates and stores the YAML text
+# as-is.
+#
+# Tests verify:
+# - The partial renders a textarea with YAML codemirror configuration for a stored YAML string.
+# - The textarea has the correct CSS classes and data attributes for the codemirror editor.
+# - A stored YAML text value (Hash-shaped) is displayed unchanged, without re-encoding it.
+# - A stored YAML text value (Array-shaped) is displayed unchanged.
+# - A nil/blank value renders an empty editor without raising errors.
+
+RSpec.describe 'common_templates/edit_fields/_name_starts_with_yaml_object', type: :view do
+  let(:field_name_sym) { :yaml_object_config }
+  let(:field_name) { 'yaml_object_config' }
+  let(:form_object_item_type_us) { 'dynamic_model__test_records' }
+  let(:labels) { {} }
+
+  let(:form_object_instance) do
+    obj = double('FormObjectInstance')
+    allow(obj).to receive(:[]).with('yaml_object_config').and_return(stored_value)
+    allow(obj).to receive(:attributes).and_return({ 'yaml_object_config' => stored_value })
+    obj
+  end
+
+  let(:form) do
+    f = double('FormBuilder')
+    allow(f).to receive(:text_area) do |field, opts|
+      "<textarea name=\"#{field}\" class=\"#{opts[:class]}\" data-code-editor-type=\"#{opts.dig(:data, :code_editor_type)}\">#{opts[:value]}</textarea>".html_safe
+    end
+    allow(f).to receive(:object).and_return(form_object_instance)
+    f
+  end
+
+  before do
+    # Stub helpers that are called by the partial
+    without_partial_double_verification do
+      allow(view).to receive(:field_options_for).and_return({})
+      allow(view).to receive(:edit_field_label) do |_form, _sym, _labels, _pattern = nil|
+        '<label>Yaml object config</label>'.html_safe
+      end
+    end
+  end
+
+  def render_partial
+    render partial: 'common_templates/edit_fields/name_starts_with_yaml_object',
+           locals: {
+             form: form,
+             field_name_sym: field_name_sym,
+             field_name: field_name,
+             form_object_item_type_us: form_object_item_type_us,
+             form_object_instance: form_object_instance,
+             labels: labels,
+             locals: {}
+           }
+  end
+
+  context 'when the field holds an existing YAML text value' do
+    let(:stored_value) { "key1: value1\nkey2: 42\n" }
+
+    it 'renders a textarea with the YAML codemirror CSS class' do
+      render_partial
+
+      expect(rendered).to include('code-editor-yaml')
+    end
+
+    it 'sets data-code-editor-type to yaml' do
+      render_partial
+
+      expect(rendered).to include('data-code-editor-type="yaml"')
+    end
+
+    it 'displays the stored YAML text unchanged, without re-encoding it' do
+      render_partial
+
+      expect(rendered).to include('key1: value1')
+      expect(rendered).to include('key2: 42')
+      expect(rendered).not_to include("--- '")
+    end
+  end
+
+  context 'when the field holds an existing YAML array text value' do
+    let(:stored_value) { "- first\n- second\n" }
+
+    it 'displays the stored YAML text unchanged' do
+      render_partial
+
+      expect(rendered).to include('- first')
+      expect(rendered).to include('- second')
+    end
+  end
+
+  context 'when the field holds a nil value' do
+    let(:stored_value) { nil }
+
+    it 'renders without error' do
+      expect { render_partial }.not_to raise_error
+    end
+
+    it 'renders a textarea with YAML codemirror CSS class' do
+      render_partial
+
+      expect(rendered).to include('code-editor-yaml')
+    end
+  end
+end

From 81b5a58630e849d7e855d09c71071209630ae031 Mon Sep 17 00:00:00 2001
From: Phil Ayres <phil_ayres@hms.harvard.edu>
Date: Tue, 21 Jul 2026 12:15:20 +0100
Subject: [PATCH 2/2] Fixed omitted field updates and strengthened YAML object
 specs - fixes #1269

---
 app/models/dynamic/field_edit_as/handler.rb   | 15 ++++++++
 .../dynamic/field_edit_as/handler_spec.rb     | 37 +++++++++++++++++++
 .../dynamic_model_yaml_object_spec.rb         | 24 ++++++++++++
 3 files changed, 76 insertions(+)

diff --git a/app/models/dynamic/field_edit_as/handler.rb b/app/models/dynamic/field_edit_as/handler.rb
index b5a5dc4f55..1afbf916ec 100644
--- a/app/models/dynamic/field_edit_as/handler.rb
+++ b/app/models/dynamic/field_edit_as/handler.rb
@@ -37,12 +37,16 @@ def initialize(object_instance, params)
       # Translate all params in the @object_instance to a persistable value,
       # based on the edit_as configuration
       # Returns a hash of any params that have been updated, so they can be merged in
+      # Fields absent from the submitted params are skipped entirely (rather than being
+      # translated from a nil value), so a partial params submission cannot silently wipe
+      # out a previously persisted value for a field that simply wasn't included this time.
       # @return [Hash]
       def translate_to_persistable
         res = {}
         edit_as_field_types.each do |field_name, edit_as_field_type|
           use = TransformFieldTypes.find { |f| edit_as_field_type.include? f }
           next unless use
+          next unless params_key?(field_name)
 
           value = params[field_name]
           new_value = "dynamic/field_edit_as/#{use}".camelize.constantize.persistable_value(value)
@@ -55,6 +59,17 @@ def translate_to_persistable
 
       private
 
+      #
+      # True if the submitted params include an entry for field_name, checked as both a
+      # Symbol and a String key, so absent fields can be skipped rather than translated
+      # from nil (which would otherwise overwrite/clear the persisted value). Works for
+      # ActionController::Parameters (already indifferent) and plain Hash params (e.g. specs).
+      # @param [Symbol] field_name
+      # @return [Boolean]
+      def params_key?(field_name)
+        params.key?(field_name) || params.key?(field_name.to_s)
+      end
+
       #
       # Return a hash of field_options: <field>: edit_as: field_type: <field type value> as
       # { <field>: <field type value> }
diff --git a/spec/models/dynamic/field_edit_as/handler_spec.rb b/spec/models/dynamic/field_edit_as/handler_spec.rb
index ec0363cb04..4de4ef72ba 100644
--- a/spec/models/dynamic/field_edit_as/handler_spec.rb
+++ b/spec/models/dynamic/field_edit_as/handler_spec.rb
@@ -154,5 +154,42 @@ def build_object_instance(attribute_names:, column_types:, field_options: {})
 
       expect(handler.translate_to_persistable).to eq({})
     end
+
+    it 'does not include a yaml_object_* field in the persistable hash when it is absent ' \
+       'from submitted params (partial update safety)' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_config],
+        column_types: { 'yaml_object_config' => :text }
+      )
+
+      handler = described_class.new(object_instance, {})
+
+      expect(handler.translate_to_persistable).to eq({})
+    end
+
+    it 'does not include a col_type_json field in the persistable hash when it is absent ' \
+       'from submitted params (partial update safety)' do
+      object_instance = build_object_instance(
+        attribute_names: %w[settings],
+        column_types: { 'settings' => :jsonb }
+      )
+
+      handler = described_class.new(object_instance, {})
+
+      expect(handler.translate_to_persistable).to eq({})
+    end
+
+    it 'still translates a yaml_object_* field present in submitted params alongside other omitted fields' do
+      object_instance = build_object_instance(
+        attribute_names: %w[yaml_object_config other_field],
+        column_types: { 'yaml_object_config' => :text, 'other_field' => :string }
+      )
+      yaml_text = "key1: value1\n"
+      params = { yaml_object_config: yaml_text }
+
+      handler = described_class.new(object_instance, params)
+
+      expect(handler.translate_to_persistable).to eq(yaml_object_config: yaml_text)
+    end
   end
 end
diff --git a/spec/system/dynamic_model/dynamic_model_yaml_object_spec.rb b/spec/system/dynamic_model/dynamic_model_yaml_object_spec.rb
index 28b3e5bafb..db8136027c 100644
--- a/spec/system/dynamic_model/dynamic_model_yaml_object_spec.rb
+++ b/spec/system/dynamic_model/dynamic_model_yaml_object_spec.rb
@@ -154,6 +154,19 @@ def setup_yaml_object_dm
 
       within(show_selector) do
         expect(page).to have_css('li.typeof-object-field[data-field-name="yaml_object_config"]', wait: 10)
+
+        # The nested key/value content sits inside a Bootstrap 'collapse' block that is
+        # collapsed by default, so it must be read with visible: :all rather than
+        # requiring it to be on-screen. This confirms the parsed YAML content actually
+        # rendered (name/items/one/two), not just that the container element exists.
+        object_field = find('li.typeof-object-field[data-field-name="yaml_object_config"]', visible: :all, wait: 10)
+        content = object_field.text(:all).downcase
+
+        expect(content).to include('name')
+        expect(content).to include('test')
+        expect(content).to include('items')
+        expect(content).to include('one')
+        expect(content).to include('two')
       end
     end
 
@@ -212,6 +225,17 @@ def setup_yaml_object_dm
       expect(page).to have_css(show_selector, wait: 10)
       within(show_selector) do
         expect(page).to have_css('li.typeof-object-field[data-field-name="yaml_object_config"]', wait: 10)
+
+        # As above, read with visible: :all since the nested content sits inside a
+        # collapsed Bootstrap block by default - confirms the updated YAML content
+        # (key/new_key/updated_value/added) actually rendered, not just the container.
+        object_field = find('li.typeof-object-field[data-field-name="yaml_object_config"]', visible: :all, wait: 10)
+        content = object_field.text(:all).downcase
+
+        expect(content).to include('key')
+        expect(content).to include('updated')
+        expect(content).to include('new key')
+        expect(content).to include('added')
       end
     end
   end