markdown_exec 3.5.1 → 3.6.0

data/lib/hash_delegator.rb

@@ -27,6 +27,7 @@ require_relative 'constants'
 require_relative 'directory_searcher'
 require_relative 'error_reporting'
 require_relative 'evaluate_shell_expressions'
+require_relative 'executed_shell_command'
 require_relative 'exceptions'
 require_relative 'fcb'
 require_relative 'filter'
@@ -43,12 +44,12 @@ require_relative 'streams_out'
 require_relative 'string_util'
 require_relative 'table_extractor'
 require_relative 'text_analyzer'
+require_relative 'transformed_shell_command'
 require_relative 'value_or_exception'
 require_relative 'env_interface'
 
 $pd = false unless defined?($pd)
 $table_cell_truncate = true
-EXIT_STATUS_REQUIRED_EMPTY = 248
 
 module HashDelegatorSelf
   # Applies an ANSI color method to a string using a specified color key.
@@ -164,8 +165,7 @@ module HashDelegatorSelf
 
   # delete the current line if it is empty and the previous is also empty
   def delete_consecutive_blank_lines!(blocks_menu)
-    blocks_menu.process_and_conditionally_delete! do
-      |prev_item, current_item, _next_item|
+    blocks_menu.process_and_conditionally_delete! do |prev_item, current_item, _next_item|
       !current_item.is_split? &&
         prev_item&.fetch(:chrome, nil) &&
         !(prev_item && prev_item.oname.present?) &&
@@ -181,6 +181,125 @@ module HashDelegatorSelf
     )
   end
 
+  # Executes a bash script from an array of lines and optionally exports the result.
+  #
+  # Creates a temporary executable file from the provided bash script lines,
+  # executes it using the configured shell, and optionally archives the script
+  # if archiving is enabled. The result can be marked as exportable based on
+  # the export configuration and command success status.
+  #
+  # @param bash_script_lines [Array<String>] An array of strings representing
+  #   the lines of the bash script to execute.
+  # @param export [Object, nil] An export configuration object that determines
+  #   whether the result should be exported. If provided, must respond to:
+  #   - `exportable` [Boolean, nil] Whether the result is exportable (nil defaults to true)
+  #   - `name` [String] The name of the variable to export the result to
+  #   If nil, the result will not be exported.
+  # @param force [Boolean] Whether to force the export even if the variable
+  #   already exists. This is included in the new_lines hash if exportable.
+  #
+  # @return [Array, nil] Returns an array with three elements:
+  #   - [0] [CommandResult] The result of executing the script, containing
+  #     stdout and exit_status
+  #   - [1] [Boolean] Whether the result is exportable (true if export is nil
+  #     or export.exportable is nil, otherwise based on export.exportable and
+  #     command success)
+  #   - [2] [Array<Hash>] An array of hashes representing new lines to export.
+  #     Each hash contains:
+  #     - `:name` [String] The variable name
+  #     - `:force` [Boolean] Whether to force the export
+  #     - `:text` [String] The text content to export
+  #   Returns nil if an error occurs during execution.
+  #
+  # @note The method creates a temporary file with mode 0755 (executable) and
+  #   automatically cleans it up after execution. If `@delegate_object[:archive_ad_hoc_scripts]`
+  #   is true, the script will be copied to an archive location before execution.
+  #
+  # @example Basic execution without export
+  #   result, exportable, new_lines = execute_bash_script_lines(
+  #     transient_code: ["echo 'Hello'", "echo 'World'"],
+  #     export: nil,
+  #     force: false
+  #   )
+  #   # => [CommandResult, true, []]
+  #
+  # @example Execution with export
+  #   export = OpenStruct.new(name: "MY_VAR", exportable: true)
+  #   result, exportable, new_lines = execute_bash_script_lines(
+  #     transient_code: ["echo 'Hello World'"],
+  #     export: export,
+  #     force: true
+  #   )
+  #   # => [CommandResult, true, [{name: "MY_VAR", force: true, text: "Hello World\n"}]]
+  #
+  def execute_bash_script_lines(
+    transient_code: [],
+    export: nil,
+    export_name:,
+    force: false,
+    shell:,
+    archive_script: false, # @delegate_object[:archive_ad_hoc_scripts]
+    archive_path_format: nil, # @delegate_object[:archive_path_format],
+    archive_time_format: nil # @delegate_object[:archive_time_format]
+  )
+    Tempfile.create('script_exec') do |temp_file|
+      temp_file.write(join_code_lines(transient_code))
+      temp_file.close # Close the file before chmod and execution
+      File.chmod(0o755, temp_file.path)
+
+      if archive_script && archive_path_format && archive_time_format
+        archive_filename = format(
+          archive_path_format,
+          time: Time.now.strftime(archive_time_format)
+        )
+        `cp #{temp_file.path} #{archive_filename}`
+      end
+
+      tsc = TransformedShellCommand.new(
+        "#{shell} #{temp_file.path}",
+        regex: export.validate,
+        format: export.transform
+      )
+      exportable = if export&.exportable.nil?
+                     true
+                   else
+                     (export ? export.exportable : false)
+                   end
+      new_lines = []
+
+      if false
+        # optional comment
+        new_lines << { comment: 'execute_bash_script_lines' }
+      end
+
+      exportable_success = exportable && tsc.success?
+      if exportable_success
+        new_lines << { name: export_name, force: force,
+                       text: tsc.transformed_output }
+      end
+
+      CommandResult.new(
+        exit_status: tsc.exit_code,
+        exportable: exportable_success,
+        new_lines: new_lines,
+        script: transient_code,
+        stdout: tsc.transformed_output,
+        transformed_shell_command: tsc
+      )
+    end
+  rescue StandardError
+    wwe $!, 'transient_code:', transient_code, 'export:', export
+    # warn "Error executing script: #{err.message}"
+    # return failure result
+    CommandResult.new(
+      exit_status: CommandResult::EXIT_STATUS_FAIL,
+      exportable: false,
+      new_lines: [],
+      script: transient_code,
+      stdout: ''
+    )
+  end
+
   # Takes multiple arrays as arguments, flattens them into a single array, and removes nil values.
   # @param args [Array<Array>] Variable number of arrays to be processed
   # @return [Array] A single flattened array with nil values removed, or an empty array if the result is empty
@@ -207,6 +326,8 @@ module HashDelegatorSelf
 
   def join_code_lines(lines)
     ((lines || []) + ['']).join("\n")
+  rescue StandardError
+    wwe $!, 'lines:', lines
   end
 
   def next_link_state(
@@ -448,14 +569,14 @@ module HashDelegatorSelf
 
     # if the id is present, update the existing fcb
     if options[:id]
-      fcb = all_fcbs.find { |fcb| fcb.id == options[:id] }
+      fcb = all_fcbs.find { _1.id == options[:id] }
       if fcb
         fcb.update(options)
         return fcb
       end
     end
-    MarkdownExec::FCB.new(options).tap do |fcb|
-      all_fcbs << fcb
+    MarkdownExec::FCB.new(options).tap do
+      all_fcbs << _1
     end
   end
 end
@@ -656,11 +777,11 @@ module MarkdownExec
         source: OpenStruct.new
       )
       @link_history = LinkHistory.new
-      @fout = FOut.new(@delegate_object) ### slice only relevant keys
+      @fout = FOut.new(@delegate_object)
 
       @process_mutex = Mutex.new
       @process_cv = ConditionVariable.new
-      @dml_link_state = Struct.new(:document_filename, :inherited_lines)
+      @dml_link_state = Struct.new(:document_filename, :context_code)
                               .new(@delegate_object[:filename], [])
       @dml_menu_blocks = []
       @fcb_store = [] # all fcbs created
@@ -729,7 +850,7 @@ module MarkdownExec
       add_inherited_lines(
         link_state: link_state,
         menu_blocks: menu_blocks
-      ) if @delegate_object[:menu_with_inherited_lines]
+      ) if @delegate_object[:menu_with_context_code]
 
       # back before exit
       add_back_option(
@@ -848,10 +969,10 @@ module MarkdownExec
     # @param menu_blocks [Array] The array of menu block elements.
     # @param position [Symbol] The position to insert the divider (:initial or :final).
     def append_inherited_lines(link_state:, menu_blocks:, position: top)
-      return unless link_state.inherited_lines_present?
+      return unless link_state.context_code_present?
 
       insert_at_top = @delegate_object[:menu_inherited_lines_at_top]
-      chrome_blocks = link_state.inherited_lines_map do |line|
+      chrome_blocks = link_state.context_code_map do |line|
         formatted = format(@delegate_object[:menu_inherited_lines_format],
                            { line: line })
         persist_fcb(
@@ -883,7 +1004,6 @@ module MarkdownExec
     # @param block_type_color_option [Symbol, nil] The shell color option to apply.
     # @return [String] The colorized or original name string.
     def apply_block_type_color_option(name, block_type_color_option)
-      ### accept string for color
       if block_type_color_option && @delegate_object[block_type_color_option].present?
         string_send_color(name, block_type_color_option)
       else
@@ -1070,7 +1190,7 @@ module MarkdownExec
       occurrence_expressions: nil
     )
       evaluate_shell_expressions(
-        (link_state&.inherited_lines_block || ''),
+        (link_state&.context_code_block || ''),
         commands,
         initial_code_required: initial_code_required,
         occurrence_expressions: occurrence_expressions
@@ -1089,7 +1209,7 @@ module MarkdownExec
           exts: '.out.txt',
           saved_asset_format:
             shell_escape_asset_format(
-              code_lines: @dml_link_state.inherited_lines,
+              transient_code: @dml_link_state.context_code,
               shell: ShellType::BASH
             )
         ).generate_name
@@ -1123,7 +1243,9 @@ module MarkdownExec
         symbol_raw_literal:
           @delegate_object[:import_symbol_raw_literal],
         symbol_variable_reference:
-          @delegate_object[:import_symbol_variable_reference]
+          @delegate_object[:import_symbol_variable_reference],
+        hide_shebang:
+          @delegate_object.fetch(:hide_shebang, true)
       )
     end
 
@@ -1142,7 +1264,9 @@ module MarkdownExec
     end
 
     # return code resulting from evaluating all automatic blocks in order
-    def code_from_auto_blocks(all_blocks, mdoc: nil, default_only: true)
+    def inherited_lines_from_auto_blocks(
+      all_blocks, mdoc: nil, default_only: true, context_code: []
+    )
       shell_block_name = @delegate_object[:document_load_shell_block_name]
       vars_block_name = @delegate_object[:document_load_vars_block_name]
 
@@ -1155,21 +1279,26 @@ module MarkdownExec
       @vars_most_recent_filename = @delegate_object[:filename]
 
       all_code = []
+      all_inherit = []
       all_blocks.each do |fcb|
         block_code = []
+        block_inherit = []
         if fcb.oname == shell_block_name
           if read_shell
             # collect code from shell block
             code = if mdoc
-                     mdoc.collect_recursively_required_code(
+                     required_code = mdoc.collect_recursively_required_code(
                        anyname: fcb.id,
-                       ### anyname: fcb.pub_name,
                        label_format_above:
                          @delegate_object[:shell_code_label_format_above],
                        label_format_below:
                          @delegate_object[:shell_code_label_format_below],
-                       block_source: block_source
-                     )[:code]
+                       block_source: block_source,
+                       context_code: context_code
+                     )
+                     block_inherit = required_code[:context_code]
+
+                     required_code[:transient_code]
                    else
                      fcb.body
                    end
@@ -1207,80 +1336,12 @@ module MarkdownExec
 
         wwt :code, 'block_code:', block_code unless block_code&.empty?
         all_code += block_code
+        all_inherit += block_inherit
       end
 
-      all_code.tap { wwt :code, _1 }
+      all_code.tap { wwr _1 }
     rescue StandardError
-      wwe 'all_blocks.count:', all_blocks.count
-    end
-
-    # return code resulting from evaluating all automatic SHELL blocks in order
-    def code_from_auto_shell_blocks(all_blocks, mdoc: nil)
-      # a block name is required
-      # do not reload the most recent filename
-      block_name = @delegate_object[:document_load_shell_block_name]
-      unless block_name.present? &&
-             @shell_most_recent_filename != @delegate_object[:filename]
-        return
-      end
-
-      @shell_most_recent_filename = @delegate_object[:filename]
-
-      # select the first block with the given name
-      fcb = HashDelegator.block_find(all_blocks, :oname, block_name)
-      return unless fcb
-
-      # collect code from shell block
-      code = if mdoc
-               mdoc.collect_recursively_required_code(
-                 anyname: fcb.pub_name,
-                 label_format_above:
-                   @delegate_object[:shell_code_label_format_above],
-                 label_format_below:
-                   @delegate_object[:shell_code_label_format_below],
-                 block_source: block_source
-               )[:code]
-             else
-               fcb.body
-             end
-      annotate_required_lines('blk:SHELL', code, block_name: fcb.id)
-    end
-
-    # return code resulting from evaluating all UX blocks in order
-    def code_from_auto_ux_blocks(
-      all_blocks,
-      mdoc
-    )
-      # do not reload the most recent filename
-      unless @ux_most_recent_filename != @delegate_object[:filename]
-        return
-      end
-
-      @ux_most_recent_filename = @delegate_object[:filename]
-
-      # select all UX blocks, rejecting non-primary split
-      blocks = select_automatic_ux_blocks(
-        all_blocks.reject(&:is_split_rest?)
-      )
-      return if blocks.empty?
-
-      # collect code from all ux blocks
-      (blocks.each.with_object([]) do |block, merged_options|
-        command_result_w_e_t_nl =
-          code_from_ux_block_to_set_environment_variables(
-            block,
-            mdoc,
-            force: @delegate_object[:ux_auto_load_force_default],
-            only_default: true,
-            silent: true
-          )
-        if command_result_w_e_t_nl.failure?
-          # if a block fails, proceed with next block
-          merged_options
-        else
-          merged_options.push(command_result_w_e_t_nl.new_lines)
-        end
-      end).to_a
+      wwe $!, 'all_blocks.count:', all_blocks.count
     end
 
     # return code resulting from evaluating all automatic VARS blocks in order
@@ -1317,91 +1378,101 @@ module MarkdownExec
     # set ENV value for the variable and return code lines for the same
     # for BlockType::UX
     def code_from_ux_block_to_set_environment_variables(
-      selected, mdoc, inherited_code: nil, force: true, only_default: false,
-      required: nil, silent:
+      selected, mdoc, context_code: nil, force: true, only_default: false,
+      required: OpenStruct.new(context_code: [], transient_code: []),
+      silent:
     )
       wwt :fcb, 'selected:', selected
+      wwt :context_code, context_code
       ret_command_result = nil
       exit_prompt = @delegate_object[:prompt_filespec_back]
 
-      required ||= mdoc.collect_recursively_required_code(
+      wwt :required, required
+      required_code = mdoc&.collect_recursively_required_code(
         anyname: selected_id_name(selected),
         label_format_above: @delegate_object[:shell_code_label_format_above],
         label_format_below: @delegate_object[:shell_code_label_format_below],
-        block_source: block_source
+        block_source: block_source,
+        context_code: context_code
       )
-      wwt :required, required
+      wwt :required_code, required_code
+      # new_inherited_lines = []
 
       # process each ux block in sequence, setting ENV and collecting lines
       concatenated_code_from_required_blocks = []
-      required[:blocks]&.each do |block|
-        next unless block.type == BlockType::UX
-
-        wwt :fcb, 'a required block', block
-
-        body1 = block.raw_body || block.body
-        case data = safe_yaml_load(body1.join("\n"))
-        when Hash
-          export = parse_yaml_of_ux_block(
-            data,
-            prompt: @delegate_object[:prompt_ux_enter_a_value],
-            validate: '^(?<name>[^ ].*)$'
-          )
-          block.export = export
-          block.export_act = FCB.act_source(export)
-          block.export_init = FCB.init_source(export)
-
-          # required are variable names that must be set before the UX block is executed.
-          # if any precondition is not set, the sequence is aborted.
-          required_variables = []
-          export.required&.each do |precondition|
-            required_variables.push "[[ -z $#{precondition} ]] && exit #{EXIT_STATUS_REQUIRED_EMPTY}"
-          end
-          wwt :required_variables, 'required_variables',
-              required_variables
-
-          eval_code = join_array_of_arrays(
-            inherited_code, # inherited code
-            concatenated_code_from_required_blocks, # current block requirements
-            required_variables, # test conditions
-            required[:code] # required by selected
-          )
-          wwt :eval_code, 'eval_code:', eval_code
-          if only_default
-            command_result_w_e_t_nl =
-              ux_block_export_automatic(eval_code, export)
-            # do not display warnings on initializing call
-            return command_result_w_e_t_nl if command_result_w_e_t_nl.failure?
+      if required_code # exclude for tests
+        required_code[:blocks]&.each do |block|
+          next if block.type != BlockType::UX
+
+          wwt :fcb, 'a required block', block
+
+          body1 = block.raw_body || block.body
+          case data = safe_yaml_load(body1.join("\n"))
+          when Hash
+            export = parse_yaml_of_ux_block(
+              data,
+              prompt: @delegate_object[:prompt_ux_enter_a_value],
+              validate: '^(?<name>[^ ].*)$'
+            )
+            block.export = export
+            block.export_act = FCB.act_source(export)
+            block.export_init = FCB.init_source(export)
+
+            # required_code are variable names that must be set before the UX block is executed.
+            # if any precondition is not set, the sequence is aborted.
+            required_variables = []
+            export.required&.each do |precondition|
+              required_variables.push "[[ -z $#{precondition} ]] && exit #{CommandResult::EXIT_STATUS_REQUIRED_EMPTY}"
+            end
+            wwt :required_variables, 'required_variables',
+                required_variables
+
+            eval_code = join_array_of_arrays(
+              required[:context_code],
+              context_code, # inherited code
+              concatenated_code_from_required_blocks, # current block requirements
+              required_variables, # test conditions
+              required[:transient_code],
+              required_code[:transient_code] # required by selected
+            )
+            wwt :eval_code, 'eval_code:', eval_code
+            if only_default
+              command_result_w_e_t_nl =
+                ux_block_export_automatic(eval_code, export)
+              # do not display warnings on initializing call
+              return command_result_w_e_t_nl if command_result_w_e_t_nl.failure?
 
-          else
-            command_result_w_e_t_nl =
-              ux_block_export_activated(eval_code, export, exit_prompt)
-            if command_result_w_e_t_nl.failure?
-              if command_result_w_e_t_nl.warning&.present? && !silent
-                warn command_result_w_e_t_nl.warning
+            else
+              command_result_w_e_t_nl =
+                ux_block_export_activated(eval_code, export, exit_prompt)
+              if command_result_w_e_t_nl.failure?
+                if command_result_w_e_t_nl.warning&.present? && !silent
+                  warn command_result_w_e_t_nl.warning
+                end
+                return command_result_w_e_t_nl
               end
-              return command_result_w_e_t_nl
             end
-          end
-          return command_result_w_e_t_nl if command_result_w_e_t_nl.failure?
+            return command_result_w_e_t_nl if command_result_w_e_t_nl.failure?
 
-          # update the required lines for this and subsequent blocks
-          command_result_w_e_t_nl.new_lines =
-            process_command_result_lines(command_result_w_e_t_nl, export,
-                                         concatenated_code_from_required_blocks)
-          concatenated_code_from_required_blocks.concat(command_result_w_e_t_nl.new_lines)
+            # update the required lines for this and subsequent blocks
+            command_result_w_e_t_nl.new_lines =
+              process_command_result_lines(command_result_w_e_t_nl, export,
+                                           concatenated_code_from_required_blocks)
+            concatenated_code_from_required_blocks.concat(command_result_w_e_t_nl.new_lines)
 
-          concatenated_code_from_required_blocks = annotate_required_lines(
-            'blk:UX', concatenated_code_from_required_blocks, block_name: selected.id
-          )
+            concatenated_code_from_required_blocks = annotate_required_lines(
+              'blk:UX', concatenated_code_from_required_blocks, block_name: selected.id
+            )
 
-          command_result_w_e_t_nl.new_lines = concatenated_code_from_required_blocks
-          ret_command_result = command_result_w_e_t_nl
-        else
-          raise "Invalid data type: #{data.inspect}"
+            command_result_w_e_t_nl.new_lines = concatenated_code_from_required_blocks
+            ret_command_result = command_result_w_e_t_nl
+          else
+            raise "Invalid data type: #{data.inspect}"
+          end
         end
       end
-      wwt :concatenated_code_from_required_blocks, concatenated_code_from_required_blocks
+      wwt :concatenated_code_from_required_blocks,
+          concatenated_code_from_required_blocks
 
       (ret_command_result || CommandResult.new(
         stdout: annotate_required_lines(
@@ -1411,19 +1482,19 @@ module MarkdownExec
         wwt :cr, ret, caller.deref
       end
     rescue StandardError
-      wwe 'selected:', selected, 'required:', required, 'block:', block,
+      wwe $!, 'selected:', selected, 'required_code:', required_code, 'block:', block,
           'data:', data
     end
 
     # def
     # sets ENV
     def code_from_vars_block_to_set_environment_variables(selected)
-      code_lines = []
+      transient_code = []
       case data = YAML.load(selected.body.join("\n"))
       when Hash
         data.each do |key, value|
           EnvInterface.set(key, value.to_s)
-          code_lines << assign_key_value_in_bash(key, value)
+          transient_code << assign_key_value_in_bash(key, value)
 
           next unless @delegate_object[:menu_vars_set_format].present?
 
@@ -1435,10 +1506,10 @@ module MarkdownExec
           print string_send_color(formatted_string, :menu_vars_set_color)
         end
       end
-      annotate_required_lines('blk:VARS', code_lines, block_name: selected.id)
+      annotate_required_lines('blk:VARS', transient_code, block_name: selected.id)
     rescue StandardError
       wwe 'selected:', selected, 'data:', data, 'key:', key, 'value:', value,
-          'code_lines:', code_lines, 'formatted_string:', formatted_string
+          'transient_code:', transient_code, 'formatted_string:', formatted_string
     end
 
     # make a single line of shell code to assign an escaped value to a variable
@@ -1495,7 +1566,8 @@ module MarkdownExec
       else
         @run_state.in_own_window = false
         command_execute_in_process(
-          args: args, command: command,
+          args: args,
+          command: command,
           erls: erls,
           filename: @delegate_object[:filename],
           shell: shell
@@ -1577,8 +1649,7 @@ module MarkdownExec
     #  containing code blocks.
     # @param selected [Hash] The selected item from the menu
     #  to be executed.
-    # @return [LoadFileLinkState] An object indicating whether to load
-    #  the next block or reuse the current one.
+    # @return [Array] context_code
     def compile_execute_and_trigger_reuse(
       mdoc:, selected:, block_source:, link_state:
     )
@@ -1595,18 +1666,18 @@ module MarkdownExec
                    end
                  end
 
-      required_lines = execute_block_type_port_code_lines(
+      required_code = execute_block_type_port_code_lines(
         mdoc: mdoc, selected: selected,
         link_state: link_state, block_source: block_source
       )
       output_or_approval = @delegate_object[:output_script] ||
                            @delegate_object[:user_must_approve]
       if output_or_approval
-        display_required_code(required_lines: required_lines)
+        display_required_code(required_lines: required_code[:transient_code])
       end
       allow_execution = if @delegate_object[:user_must_approve]
                           prompt_for_user_approval(
-                            required_lines: required_lines,
+                            required_lines: required_code[:transient_code],
                             selected: selected
                           )
                         else
@@ -1614,16 +1685,28 @@ module MarkdownExec
                         end
 
       if allow_execution
+        script_lines = ( #HashDelegator.join_code_lines(
+          # ['# prior context'] +
+          (link_state&.context_code || []) +
+          # ['# new context'] +
+          required_code[:context_code] +
+          # ['# new transient'] +
+          required_code[:transient_code]
+        )
         execute_required_lines(
           blockname: selected_id_name(selected),
           erls: { play_bin: play_bin,
                   shell: selected_shell(selected.shell) },
-          required_lines: required_lines,
+          script_lines: script_lines,
           shell: selected_shell(selected.shell)
         )
       end
 
       link_state.block_name = nil
+
+      required_code[:context_code]
+    rescue StandardError
+      wwe $!
     end
 
     # Check if the expression contains wildcard characters
@@ -1887,16 +1970,7 @@ module MarkdownExec
         case_conversion: criteria[:case_conversion],
         center: criteria[:center] &&
                 @delegate_object[criteria[:center]],
-
-        collapse: case fcb.collapse_token
-                  when COLLAPSIBLE_TOKEN_COLLAPSE
-                    true
-                  when COLLAPSIBLE_TOKEN_EXPAND
-                    false
-                  else
-                    false
-                  end,
-
+        collapse: fcb.collapse_token == COLLAPSIBLE_TOKEN_COLLAPSE,
         color_method: criteria[:color] &&
                       @delegate_object[criteria[:color]].to_sym,
         decor_patterns:
@@ -1943,6 +2017,8 @@ module MarkdownExec
       # filter block if selected in menu
       return true if @run_state.source.block_name_from_cli
 
+      return true if @delegate_object[:block_name].empty?
+
       # return false if @prior_execution_block == @delegate_object[:block_name]
       if @prior_execution_block == @delegate_object[:block_name]
         return @allowed_execution_block == @prior_execution_block ||
@@ -2119,10 +2195,10 @@ module MarkdownExec
         warn format_and_highlight_lines(link_state.inherited_dependencies,
                                         label: 'inherited_dependencies')
       end
-      return unless @delegate_object[:dump_inherited_lines]
+      return unless @delegate_object[:dump_context_code]
 
-      warn format_and_highlight_lines(link_state.inherited_lines,
-                                      label: 'inherited_lines')
+      warn format_and_highlight_lines(link_state.context_code,
+                                      label: 'context_code')
     end
 
     # Opens text in an editor for user modification and
@@ -2208,7 +2284,7 @@ module MarkdownExec
         vux_edit_inherited
         return :break if pause_user_exit
 
-        next_state_append_code(selected, link_state, [])
+        next_state_append_code(selected, link_state, context_code: [])
 
       elsif selected.type == BlockType::HISTORY
         debounce_reset
@@ -2221,23 +2297,25 @@ module MarkdownExec
 
       elsif selected.type == BlockType::LINK
         debounce_reset
-        execute_block_type_link_with_state(link_block_body: selected.body,
-                                           mdoc: mdoc,
-                                           selected: selected,
-                                           link_state: link_state,
-                                           block_source: block_source)
+        execute_block_type_link_with_state(
+          link_block_body: selected.body,
+          mdoc: mdoc,
+          selected: selected,
+          link_state: link_state,
+          block_source: block_source
+        )
 
       elsif selected.type == BlockType::LOAD
         debounce_reset
         load_result = execute_block_type_load_code_lines(selected)
-        next_state_append_code(selected, link_state, load_result.code,
-                               mode: load_result.mode)
+        next_state_append_code(selected, link_state, context_code: load_result.code,
+                                                     mode: load_result.mode)
 
       elsif selected.type == BlockType::SAVE
         debounce_reset
 
         execute_block_type_save(
-          code_lines: link_state&.inherited_lines,
+          transient_code: link_state&.context_code,
           selected: selected
         )
 
@@ -2259,7 +2337,7 @@ module MarkdownExec
 
       elsif selected.type == BlockType::OPTS
         debounce_reset
-        code_lines = []
+        transient_code = []
         options_state = read_show_options_and_trigger_reuse(
           link_state: link_state,
           mdoc: @dml_mdoc,
@@ -2268,7 +2346,7 @@ module MarkdownExec
         update_menu_base(options_state.options)
 
         link_state = LinkState.new
-        next_state_append_code(selected, link_state, code_lines)
+        next_state_append_code(selected, link_state, context_code: transient_code)
 
       elsif selected.type == BlockType::PORT
         debounce_reset
@@ -2277,23 +2355,22 @@ module MarkdownExec
           selected: selected,
           link_state: link_state,
           block_source: block_source
-        )
-        next_state_set_code(selected, link_state, required_lines)
+        )[:context_code]
+        next_state_append_code(selected, link_state, context_code: required_lines)
 
       elsif selected.type == BlockType::UX
         debounce_reset
         command_result_w_e_t_nl = code_from_ux_block_to_set_environment_variables(
           selected,
           @dml_mdoc,
-          inherited_code: @dml_link_state.inherited_lines,
+          context_code: @dml_link_state.context_code,
           only_default: false,
           silent: true
         )
-        ### TBD if command_result_w_e_t_nl.failure?
         next_state_append_code(
           selected,
           link_state,
-          command_result_w_e_t_nl.failure? ? [] : command_result_w_e_t_nl.new_lines
+          context_code: command_result_w_e_t_nl.failure? ? [] : command_result_w_e_t_nl.new_lines
         )
 
       elsif selected.type == BlockType::VARS
@@ -2301,7 +2378,7 @@ module MarkdownExec
         next_state_append_code(
           selected,
           link_state,
-          code_from_vars_block_to_set_environment_variables(selected)
+          context_code: code_from_vars_block_to_set_environment_variables(selected)
         )
 
       elsif COLLAPSIBLE_TYPES.include?(selected.type)
@@ -2310,11 +2387,14 @@ module MarkdownExec
         LoadFileLinkState.new(LoadFile::REUSE, link_state)
 
       elsif debounce_allows
-        compile_execute_and_trigger_reuse(mdoc: mdoc,
-                                          selected: selected,
-                                          link_state: link_state,
-                                          block_source: block_source)
-        LoadFileLinkState.new(LoadFile::REUSE, link_state)
+        # SHELL type
+        context_code = compile_execute_and_trigger_reuse(
+          mdoc: mdoc,
+          selected: selected,
+          link_state: link_state,
+          block_source: block_source
+        )
+        next_state_set_code(selected, link_state, context_code)
 
       else
         LoadFileLinkState.new(LoadFile::REUSE, link_state)
@@ -2408,29 +2488,31 @@ module MarkdownExec
       ## collect blocks specified by block
       #
       if mdoc
-        code_info = mdoc.collect_recursively_required_code(
+        required_code = mdoc.collect_recursively_required_code(
           anyname: selected_id_name(selected),
           block_source: block_source,
           label_format_above: @delegate_object[:shell_code_label_format_above],
-          label_format_below: @delegate_object[:shell_code_label_format_below]
+          label_format_below: @delegate_object[:shell_code_label_format_below],
+          context_code: link_state&.context_code || []
         )
-        code_lines = annotate_required_lines(
-          'blk:LINK', code_info[:code], block_name: selected.id
+
+        context_code = annotate_required_lines(
+          'blk:LINK', required_code[:context_code], block_name: selected.id
         )
-        block_names = code_info[:block_names]
-        dependencies = code_info[:dependencies]
+        block_names = required_code[:block_names]
+        dependencies = required_code[:dependencies]
       else
         block_names = []
-        code_lines = []
+        context_code = []
         dependencies = {}
       end
 
       # load key and values from link block into current environment
       #
       if link_block_data[LinkKeys::VARS]
-        code_lines << BashCommentFormatter.format_comment(selected.pub_name)
+        context_code << BashCommentFormatter.format_comment(selected.pub_name)
         link_block_data[LinkKeys::VARS].each do |key, value|
-          code_lines << assign_key_value_in_bash(key, value)
+          context_code << assign_key_value_in_bash(key, value)
           EnvInterface.set(key, value.to_s)
         end
       end
@@ -2441,20 +2523,20 @@ module MarkdownExec
         load_filespec = load_filespec_from_expression(load_expr)
         if load_filespec
           begin
-            code_lines += File.readlines(load_filespec,
-                                         chomp: true)
+            context_code += File.readlines(load_filespec,
+                                           chomp: true)
           rescue Errno::ENOENT
             report_error($ERROR_INFO)
           end
         end
       end
 
-      # if an eval link block, evaluate code_lines and return its standard output
+      # if an eval link block, evaluate context_code and return its standard output
       #
       if link_block_data.fetch(LinkKeys::EVAL, false) ||
          link_block_data.fetch(LinkKeys::EXEC, false)
-        code_lines = link_block_data_eval(
-          link_state, code_lines, selected, link_block_data,
+        context_code = link_block_data_eval(
+          link_state, context_code, selected, link_block_data,
           block_source: block_source,
           shell: @delegate_object[:block_type_default]
         )
@@ -2469,13 +2551,16 @@ module MarkdownExec
         nil
       ) || link_block_data.fetch(LinkKeys::BLOCK, nil) || ''
 
-      code_lines = annotate_required_lines(
-        'blk:LINK', code_lines, block_name: selected.id
+      context_code = annotate_required_lines(
+        'blk:LINK', context_code, block_name: selected.id
+      )
+      context_code = annotate_required_lines(
+        'blk:LINK', context_code, block_name: selected.id
       )
 
       if link_block_data[LinkKeys::RETURN]
         pop_add_current_code_to_head_and_trigger_load(
-          link_state, block_names, code_lines,
+          link_state, block_names, context_code,
           dependencies, selected, next_block_name: next_block_name
         )
 
@@ -2488,8 +2573,8 @@ module MarkdownExec
             ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
           inherited_dependencies:
             (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
-          inherited_lines: HashDelegator.flatten_and_compact_arrays(
-            link_state&.inherited_lines, code_lines
+          context_code: HashDelegator.flatten_and_compact_arrays(
+            link_state&.context_code, context_code
           ),
           keep_code: link_state&.keep_code,
           next_block_name: next_block_name,
@@ -2586,31 +2671,34 @@ module MarkdownExec
     #
     # @param mdoc [YourMDocClass] An instance of the MDoc class.
     # @param selected [Hash] The selected block.
-    # @return [Array<String>] Required code blocks as an array of lines.
+    # @return [OpenStruct] context and transient code
     def execute_block_type_port_code_lines(mdoc:, selected:, block_source:,
                                            link_state: LinkState.new)
-      required = mdoc.collect_recursively_required_code(
+      required_code = mdoc.collect_recursively_required_code(
         anyname: selected_id_name(selected),
         label_format_above: @delegate_object[:shell_code_label_format_above],
         label_format_below: @delegate_object[:shell_code_label_format_below],
-        block_source: block_source
-      ) # !!t 'required'
+        block_source: block_source,
+        context_code: link_state&.context_code || []
+      ) # !!t 'required_code'
       dependencies = (
         link_state&.inherited_dependencies || {}
-      ).merge(required[:dependencies] || {})
-      required[:unmet_dependencies] = (
-        required[:unmet_dependencies] || []
+      ).merge(required_code[:dependencies] || {})
+
+      required_code[:unmet_dependencies] = (
+        required_code[:unmet_dependencies] || []
       ) - (link_state&.inherited_block_names || [])
-      if required[:unmet_dependencies].present?
+
+      if required_code[:unmet_dependencies].present?
         ### filter against link_state.inherited_block_names
 
         warn format_and_highlight_dependencies(
-          dependencies, highlight: required[:unmet_dependencies]
+          dependencies, highlight: required_code[:unmet_dependencies]
         )
         runtime_exception(
           :runtime_exception_error_level,
           'unmet_dependencies, flag: runtime_exception_error_level',
-          required[:unmet_dependencies]
+          required_code[:unmet_dependencies]
         )
       elsif @delegate_object[:dump_dependencies]
         warn format_and_highlight_dependencies(
@@ -2621,43 +2709,55 @@ module MarkdownExec
 
       if selected[:type] == BlockType::OPTS
         # body of blocks is returned as a list of lines to be read an YAML
-        HashDelegator.flatten_and_compact_arrays(
-          required[:blocks].map(&:body).flatten(1)
+        OpenStruct.new(
+          context_code: HashDelegator.flatten_and_compact_arrays(
+            required_code[:blocks].map(&:body).flatten(1)
+          ),
+          transient_code: []
         )
       else
         # code from the selected VARS block
         vars_code = if selected.type == BlockType::VARS
-                       code_from_vars_block_to_set_environment_variables(selected)
-                     else
-                       []
-                     end
+                      code_from_vars_block_to_set_environment_variables(selected)
+                    else
+                      []
+                    end
 
-        # activate UX blocks in the required list
+        # activate UX blocks in the required_code list
         command_result_w_e_t_nl = code_from_ux_block_to_set_environment_variables(
           selected,
           @dml_mdoc,
-          inherited_code: vars_code,
+          context_code: required_code[:context_code] + required_code[:transient_code],
           only_default: false,
-          required: required,
+          required:
+            OpenStruct.new(context_code: [], transient_code: vars_code),
           silent: false
         )
         ux_code = command_result_w_e_t_nl.failure? ? [] : command_result_w_e_t_nl.new_lines
 
-        HashDelegator.flatten_and_compact_arrays(
-          link_state&.inherited_lines,
-          annotate_required_lines(
-            'blk:PORT',
-            required[:code] + vars_code + ux_code,
-            block_name: selected.id
+        OpenStruct.new(
+          context_code: HashDelegator.flatten_and_compact_arrays(
+            link_state&.context_code,
+            annotate_required_lines(
+              'blk:PORT',
+              (required_code[:context_code] || []) + vars_code + ux_code,
+              block_name: selected.id
+            )
+          ),
+          transient_code: HashDelegator.flatten_and_compact_arrays(
+            annotate_required_lines(
+              'blk:PORT',
+              required_code[:transient_code],
+              block_name: selected.id
+            )
           )
         )
       end
-
     rescue StandardError
-      wwe(required[:code], ux_code, { error: $!, callback: $@[0] })
+      wwe(required_code, ux_code, { error: $!, callback: $@[0] })
     end
 
-    def execute_block_type_save(code_lines:, selected:)
+    def execute_block_type_save(transient_code:, selected:)
       block_data = HashDelegator.parse_yaml_data_from_body(selected.body)
       directory_glob = if block_data['directory']
                          File.join(
@@ -2678,7 +2778,7 @@ module MarkdownExec
             end
 
             File.write(save_filespec,
-                       HashDelegator.join_code_lines(code_lines))
+                       HashDelegator.join_code_lines(transient_code))
           rescue Errno::ENOENT
             report_error($ERROR_INFO)
           end
@@ -2773,14 +2873,14 @@ module MarkdownExec
     end
 
     def execute_inherited_save(
-      code_lines: @dml_link_state.inherited_lines
+      transient_code: @dml_link_state.context_code
     )
       return unless (save_filespec = save_filespec_from_expression(
         document_name_in_glob_as_file_name
       ))
 
       unless write_file_with_directory_creation(
-        content: HashDelegator.join_code_lines(code_lines),
+        content: HashDelegator.join_code_lines(transient_code),
         filespec: save_filespec
       )
         :break
@@ -2791,14 +2891,14 @@ module MarkdownExec
       @menu_user_clicked_back_link = true
 
       keep_code = @dml_link_state.keep_code
-      inherited_lines = keep_code ? @dml_link_state.inherited_lines_block : nil
+      context_code = keep_code ? @dml_link_state.context_code_block : nil
 
       @dml_link_state = pop_link_history_new_state
 
       {
         block_name: @dml_link_state.block_name,
         document_filename: @dml_link_state.document_filename,
-        inherited_lines: inherited_lines,
+        context_code: context_code,
         keep_code: keep_code
       }
     end
@@ -2814,23 +2914,25 @@ module MarkdownExec
     def execute_required_lines(
       blockname: '',
       erls: {},
-      required_lines: [],
+      script_lines: [],
       shell:
     )
       if @delegate_object[:save_executed_script]
         write_command_file(blockname: blockname,
-                           required_lines: required_lines,
+                           required_lines: script_lines,
                            shell: selected_shell(shell))
       end
       if @dml_block_state
         calc_logged_stdout_filename(block_name: @dml_block_state.block.oname)
       end
       format_and_execute_command(
-        code_lines: required_lines,
+        script_lines: script_lines,
         erls: erls,
         shell: selected_shell(shell)
       )
       post_execution_process
+    rescue StandardError
+      wwe $!
     end
 
     def expand_blocks_with_replacements(
@@ -2926,7 +3028,8 @@ module MarkdownExec
     end
 
     def ux_block_eval_for_export(
-      bash_script_lines, export,
+      bash_script_lines,
+      export,
       data:,
       first_only: false,
       force:,
@@ -2934,68 +3037,90 @@ module MarkdownExec
       silent:,
       string: nil
     )
-      exportable = true
       command_result = nil
       new_lines = []
+      required_lines = []
       export_string = string.nil? ? data : string
       expander = ->(expression) { %(printf '%s' "#{expression}") }
+      exportable = true
 
       case export_string
       when String, Integer, Float, TrueClass, FalseClass
-        command_result, exportable, = output_from_adhoc_bash_script_file(
-          join_array_of_arrays(
+        command_result = HashDelegator.execute_bash_script_lines(
+          transient_code: join_array_of_arrays(
             bash_script_lines,
             printf_expand ? expander.call(export_string) : [export_string]
           ),
-          export,
-          force: force
+          export: export,
+          export_name: export.name,
+          force: force,
+          shell: @delegate_object[:shell],
+          archive_script: @delegate_object[:archive_ad_hoc_scripts],
+          archive_path_format: @delegate_object[:archive_path_format],
+          archive_time_format: @delegate_object[:archive_time_format]
         )
-        if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
+        exportable = command_result&.exportable
+
+        if command_result&.exit_status == CommandResult::EXIT_STATUS_REQUIRED_EMPTY
           exportable = false
           unless silent
             command_result.warning = warning_required_empty(export)
           end
+        elsif command_result.nil? || command_result.failure?
+          exportable = false
+          unless silent
+            command_result.warning = warning_failure(export)
+          end
         else
-          # store the transformed value in ENV
-          EnvInterface.set(export.name, command_result.stdout.to_s)
-
-          new_lines << { name: export.name, force: force,
-                         text: command_result.stdout }
+          out = command_result.stdout.to_s
+          if export_environment_variable(export.name, out)
+            new_lines << {
+              name: export.name, force: force, text: out
+            }
+            required_lines << code_line_to_assign_a_variable(
+              export.name, out, force: force
+            )
+          end
         end
 
       when Hash
-        required_lines = []
 
         # each item in the hash is a variable name and value
         export_string.each do |name, expression|
-          command_result, = output_from_adhoc_bash_script_file(
-            join_array_of_arrays(
+          command_result = HashDelegator.execute_bash_script_lines(
+            transient_code: join_array_of_arrays(
               bash_script_lines,
               required_lines,
               printf_expand ? expander.call(expression) : [expression]
             ),
-            export,
-            force: force
-          )
-          if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
+            export: export,
+            export_name: name,
+            force: force,
+            shell: @delegate_object[:shell],
+            archive_script: @delegate_object[:archive_ad_hoc_scripts],
+            archive_path_format: @delegate_object[:archive_path_format],
+            archive_time_format: @delegate_object[:archive_time_format]
+          ).tap { ww _1 }
+          if command_result.exit_status == CommandResult::EXIT_STATUS_REQUIRED_EMPTY
+            exportable = false
             unless silent
               command_result.warning = warning_required_empty(export)
             end
+          elsif command_result.failure?
+            exportable = false
+            unless silent
+              command_result.warning = warning_failure(export)
+            end
           else
-            transformed = command_result.stdout.to_s
-
-            # code for subsequent expression evaluations
+            out = command_result.stdout.to_s
+            if export_environment_variable(name, out)
+              new_lines << {
+                name: name, force: force, text: out
+              }
+            end
             required_lines << code_line_to_assign_a_variable(
-              name, transformed, force: force
+              name, out, force: force
             )
-
-            if variable_is_exportable(name)
-              # store the transformed value in ENV
-              EnvInterface.set(name, transformed)
-
-              new_lines << { name: name, force: force,
-                             text: command_result.stdout }
-            end
           end
 
           break if first_only
@@ -3004,9 +3129,23 @@ module MarkdownExec
         # do nothing
       end
 
-      [command_result, exportable, new_lines]
+      if command_result
+        command_result.exportable = exportable
+        command_result.new_lines = new_lines
+        command_result.required_lines = required_lines
+      end
+
+      command_result
     rescue StandardError
-      wwe bash_script_lines, export, force, silent, string
+      wwe $!, bash_script_lines, export, force, silent, string
+    end
+
+    def export_environment_variable(export_name, stdout)
+      return unless variable_is_exportable(export_name)
+
+      EnvInterface.set(export_name, stdout)
+
+      true
     end
 
     # Retrieves a specific data symbol from the delegate object,
@@ -3080,11 +3219,11 @@ module MarkdownExec
     end
 
     def format_and_execute_command(
-      code_lines:,
+      script_lines:,
       erls:,
       shell:
     )
-      formatted_command = code_lines.flatten.join("\n")
+      formatted_command = script_lines.flatten.join("\n")
       @fout.fout fetch_color(data_sym: :script_execution_head,
                              color_sym: :script_execution_frame_color)
 
@@ -3353,7 +3492,7 @@ module MarkdownExec
         wwt :iterlines, 'nested_line:', nested_line
         update_line_and_block_state(
           nested_line, state, selected_types,
-          source_id: "ItrBlkFrmNstFls:#{index}¤#{nested_line.filename}:#{nested_line.index}",
+          source_id: "IBNF:#{index}¤#{nested_line.filename}:#{nested_line.index}",
           &block
         )
 
@@ -3393,10 +3532,10 @@ module MarkdownExec
       end.compact.flatten(1)
     end
 
-    def link_block_data_eval(link_state, code_lines, selected, link_block_data,
+    def link_block_data_eval(link_state, transient_code, selected, link_block_data,
                              block_source:, shell:)
       all_code = HashDelegator.flatten_and_compact_arrays(
-        link_state&.inherited_lines, code_lines
+        link_state&.context_code, transient_code
       )
       output_lines = []
 
@@ -3415,34 +3554,34 @@ module MarkdownExec
             output_lines.push(line) if line
           end
 
-          if link_block_data.fetch(LinkKeys::EVAL, true)
-            # eval: true
-
-            ## select output_lines that look like assignment or match other specs
-            #
-            output_lines = process_string_array(
-              output_lines,
-              begin_pattern: @delegate_object.fetch(:output_assignment_begin,
-                                                    nil),
-              end_pattern: @delegate_object.fetch(:output_assignment_end, nil),
-              scan1: @delegate_object.fetch(:output_assignment_match, nil),
-              format1: @delegate_object.fetch(:output_assignment_format, nil),
-              name: ''
-            )
+          output_lines = if link_block_data.fetch(LinkKeys::EVAL, true)
+                           # eval: true
+
+                           ## select output_lines that look like assignment or match other specs
+                           #
+                           process_string_array(
+                             output_lines,
+                             begin_pattern: @delegate_object.fetch(:output_assignment_begin,
+                                                                   nil),
+                             end_pattern: @delegate_object.fetch(:output_assignment_end, nil),
+                             scan1: @delegate_object.fetch(:output_assignment_match, nil),
+                             format1: @delegate_object.fetch(:output_assignment_format, nil),
+                             name: ''
+                           )
 
-          else
-            # eval: false
-
-            ## select all output_lines
-            #
-            output_lines = process_string_array(
-              output_lines,
-              begin_pattern: @delegate_object.fetch(:output_assignment_begin,
-                                                    nil),
-              end_pattern: @delegate_object.fetch(:output_assignment_end, nil),
-              name: ''
-            )
-          end
+                         else
+                           # eval: false
+
+                           ## select all output_lines
+                           #
+                           process_string_array(
+                             output_lines,
+                             begin_pattern: @delegate_object.fetch(:output_assignment_begin,
+                                                                   nil),
+                             end_pattern: @delegate_object.fetch(:output_assignment_end, nil),
+                             name: ''
+                           )
+                         end
         else
           output_lines = `bash #{file.path}`.split("\n")
         end
@@ -3489,7 +3628,7 @@ module MarkdownExec
 
     def link_history_push_and_next(
       curr_block_name:, curr_document_filename:,
-      inherited_block_names:, inherited_dependencies:, inherited_lines:,
+      inherited_block_names:, inherited_dependencies:, context_code:,
       keep_code:,
       next_block_name:, next_document_filename:,
       next_keep_code:,
@@ -3501,7 +3640,7 @@ module MarkdownExec
           document_filename: curr_document_filename,
           inherited_block_names: inherited_block_names,
           inherited_dependencies: inherited_dependencies,
-          inherited_lines: inherited_lines,
+          context_code: context_code,
           keep_code: keep_code
         )
       )
@@ -3512,7 +3651,7 @@ module MarkdownExec
           document_filename: next_document_filename,
           inherited_block_names: inherited_block_names,
           inherited_dependencies: inherited_dependencies,
-          inherited_lines: inherited_lines,
+          context_code: context_code,
           keep_code: next_keep_code
         )
       )
@@ -3702,21 +3841,27 @@ module MarkdownExec
         reload_blocks = true
       end
 
+      link_state_context_code = link_state&.context_code || []
+
       # return code resulting from evaluating all SHELL, UX, VARS blocks;
       # each set in sequence; with its own order
       #
-      if (code_lines = code_from_auto_blocks(
+      if (transient_code = inherited_lines_from_auto_blocks(
         all_blocks,
         default_only: true,
-        mdoc: mdoc
+        mdoc: mdoc,
+        context_code: link_state_context_code
       ))&.select_by(:empty?, false)&.compact&.count&.positive?
-        new_code = code_lines
-        wwt :code_lines, 'code_lines:', code_lines
+        wwt :transient_code, 'transient_code:', transient_code
+
+        # prepend context code to new transient code
+        new_code = link_state_context_code + transient_code
         next_state_set_code(nil, link_state, new_code)
-        link_state.inherited_lines = new_code
+        link_state.context_code = new_code
+
         reload_blocks = true
       else
-        link_state&.inherited_lines
+        link_state&.context_code
       end
 
       if reload_blocks
@@ -3876,6 +4021,14 @@ module MarkdownExec
       end
     end
 
+    # Define respond_to_missing? to match method_missing behavior
+    def respond_to_missing?(method_name, include_private = false)
+      return true if @delegate_object.respond_to?(method_name, include_private)
+      return true if method_name.to_s.end_with?('=')
+
+      true # Any other method name is treated as a key accessor
+    end
+
     # If a method is missing, treat it as a key for the @delegate_object.
     def method_missing(method_name, *args, &block)
       if @delegate_object.respond_to?(method_name)
@@ -3895,19 +4048,19 @@ module MarkdownExec
       list[(index + 1) % list.size] # Get the next item, wrap around if at the end
     end
 
-    def next_state_append_code(selected, link_state, code_lines,
+    def next_state_append_code(selected, link_state, context_code:,
                                mode: LoadMode::APPEND)
       next_state_set_code(
         selected,
         link_state,
         HashDelegator.flatten_and_compact_arrays(
-          mode == LoadMode::APPEND ? link_state&.inherited_lines : [],
-          code_lines.is_a?(Array) ? code_lines : [] # no code for :ux_exec_prohibited
+          mode == LoadMode::APPEND ? link_state&.context_code : [],
+          context_code.is_a?(Array) ? context_code : [] # no code for :ux_exec_prohibited
         )
       )
     end
 
-    def next_state_set_code(selected, link_state, code_lines)
+    def next_state_set_code(selected, link_state, context_code)
       block_names = []
       dependencies = {}
       link_history_push_and_next(
@@ -3917,7 +4070,7 @@ module MarkdownExec
           ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
         inherited_dependencies:
           (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
-        inherited_lines: HashDelegator.flatten_and_compact_arrays(code_lines),
+        context_code: HashDelegator.flatten_and_compact_arrays(context_code),
         keep_code: link_state&.keep_code,
         next_block_name: '',
         next_document_filename: @delegate_object[:filename],
@@ -3961,60 +4114,6 @@ module MarkdownExec
       }
     end
 
-    def output_from_adhoc_bash_script_file(
-      bash_script_lines,
-      export = nil,
-      force:
-    )
-      Tempfile.create('script_exec') do |temp_file|
-        temp_file.write(
-          HashDelegator.join_code_lines(
-            bash_script_lines
-          )
-        )
-        temp_file.close # Close the file before chmod and execution
-        File.chmod(0o755, temp_file.path)
-
-        if @delegate_object[:archive_ad_hoc_scripts]
-          archive_filename = format(
-            @delegate_object[:archive_path_format],
-            time: Time.now.strftime(@delegate_object[:archive_time_format])
-          )
-          `cp #{temp_file.path} #{archive_filename}`
-        end
-
-        output = `#{shell} #{temp_file.path}`
-
-        exportable = if export&.exportable.nil?
-                       true
-                     else
-                       (export ? export.exportable : false)
-                     end
-        new_lines = []
-        # new_lines << { comment: 'output_from_adhoc_bash_script_file' }
-
-        command_result = CommandResult.new(
-          stdout: output,
-          exit_status: $?.exitstatus
-        )
-        exportable &&= command_result.success?
-        if exportable
-          new_lines << { name: export.name, force: force,
-                         text: command_result.stdout }
-        end
-
-        [
-          command_result,
-          exportable,
-          new_lines
-        ]
-      end
-    rescue StandardError => err
-      # wwe 'bash_script_lines:', bash_script_lines, 'export:', export
-      warn "Error executing script: #{err.message}"
-      nil
-    end
-
     def output_labeled_value(label, value, level)
       @fout.lout format_references_send_color(
         context: {
@@ -4036,7 +4135,7 @@ module MarkdownExec
     end
 
     def pop_add_current_code_to_head_and_trigger_load(
-      link_state, block_names, code_lines,
+      link_state, block_names, transient_code,
       dependencies, selected, next_block_name: nil
     )
       pop = @link_history.pop # updatable
@@ -4048,9 +4147,9 @@ module MarkdownExec
            (pop.inherited_block_names + block_names).sort.uniq,
           inherited_dependencies:
            dependencies.merge(pop.inherited_dependencies || {}), ### merge, not replace, key data
-          inherited_lines:
-           HashDelegator.flatten_and_compact_arrays(pop.inherited_lines,
-                                                    code_lines)
+          context_code:
+           HashDelegator.flatten_and_compact_arrays(pop.context_code,
+                                                    transient_code)
         )
         @link_history.push(next_state)
 
@@ -4066,9 +4165,9 @@ module MarkdownExec
            ((link_state&.inherited_block_names || []) + block_names).sort.uniq,
           inherited_dependencies:
            (link_state&.inherited_dependencies || {}).merge(dependencies || {}), ### merge, not replace, key data
-          inherited_lines:
+          context_code:
            HashDelegator.flatten_and_compact_arrays(
-             link_state&.inherited_lines, code_lines
+             link_state&.context_code, transient_code
            ),
           keep_code: link_state&.keep_code,
           next_block_name: next_block_name,
@@ -4093,7 +4192,7 @@ module MarkdownExec
         document_filename: pop.document_filename,
         inherited_block_names: peek.inherited_block_names,
         inherited_dependencies: peek.inherited_dependencies,
-        inherited_lines: peek.inherited_lines
+        context_code: peek.context_code
       )
     end
 
@@ -4108,7 +4207,7 @@ module MarkdownExec
       blocks.select { |item| item.type == 'ux' }
     end
 
-    # Filter blocks per block_name_include_match, block_name_wrapper_match.
+    # Filter blocks per block_name_hidden_match, block_name_wrapper_match.
     #
     # @param all_blocks [Array<Hash>] The list of blocks from the file.
     def select_blocks(menu_blocks)
@@ -4116,12 +4215,12 @@ module MarkdownExec
         Filter.prepared_not_in_menu?(
           @delegate_object,
           fcb,
-          %i[block_name_include_match block_name_wrapper_match]
+          %i[block_name_hidden_match block_name_wrapper_match]
         )
       end
     end
 
-    # Filter blocks per block_name_include_match, block_name_wrapper_match.
+    # Filter blocks per block_name_hidden_match, block_name_wrapper_match.
     # Set name displayed by tty-prompt.
     #
     # @param all_blocks [Array<Hash>] The list of blocks from the file.
@@ -4167,11 +4266,7 @@ module MarkdownExec
         if name.empty?
           "# #{comment}" unless comment.empty?
         else
-          transformed = if command_result_w_e_t_nl.transformable
-                          transform_export_value(name_force[:text], export)
-                        else
-                          name_force[:text]
-                        end
+          transformed = name_force[:text]
 
           # store the transformed value in ENV
           EnvInterface.set(name, transformed)
@@ -4473,11 +4568,13 @@ module MarkdownExec
       obj = {}
 
       # concatenated body of all required blocks loaded a YAML
+
+      rc = execute_block_type_port_code_lines(
+        mdoc: mdoc, selected: selected,
+        link_state: link_state, block_source: {}
+      )
       data = (YAML.load(
-        execute_block_type_port_code_lines(
-          mdoc: mdoc, selected: selected,
-          link_state: link_state, block_source: {}
-        ).join("\n")
+        rc[:context_code].join("\n")
       ) || {}).transform_keys(&:to_sym)
 
       if selected.type == BlockType::OPTS
@@ -4592,7 +4689,7 @@ module MarkdownExec
             @delegate_object.respond_to?(:[]=, include_private)
         true
       else
-        @delegate_object.respond_to?(method_name, include_private)
+        false
       end
     end
 
@@ -4677,8 +4774,8 @@ module MarkdownExec
         filename: filename,
         saved_asset_format:
           shell_escape_asset_format(
-            code_lines: link_state&.inherited_lines,
-            shell: selected_shell(shell)
+            transient_code: link_state&.context_code,
+            shell: selected_shell(@delegate_object[:shell])
           )
       ).generate_name
     end
@@ -4846,7 +4943,7 @@ module MarkdownExec
     end
 
     def shell_escape_asset_format(
-      code_lines:,
+      transient_code:,
       enable: @delegate_object[:shell_parameter_expansion],
       raw: @delegate_object[:saved_asset_format],
       shell:
@@ -4861,7 +4958,7 @@ module MarkdownExec
 
       marker = Random.new.rand.to_s
 
-      code = (code_lines || []) + ["echo -n \"#{marker}#{raw}\""]
+      code = (transient_code || []) + ["echo -n \"#{marker}#{raw}\""]
       File.write filespec, HashDelegator.join_code_lines(code)
       File.chmod 0o755, filespec
 
@@ -4966,7 +5063,6 @@ module MarkdownExec
     #  color_sym is not found in @delegate_object.
     # @return [String] The string with the applied color method.
     def string_send_color(string, color_sym)
-      ### accept string with color as well as symbol for color_hash
       HashDelegator.apply_color_from_hash(string, @delegate_object, color_sym)
     end
 
@@ -5094,21 +5190,20 @@ module MarkdownExec
       force = export.force.nil? ? true : export.force
       new_lines = []
       silent = false
-      transformable = true
 
       case FCB.act_source(export)
       when false, UxActSource::FALSE
         # read-only
-        command_result = CommandResult.new
-        exportable = false
-        transformable = false
+        command_result = CommandResult.new(
+          exportable: false
+        )
 
       when :allow, UxActSource::ALLOW
         raise unless export.allow.present?
 
         case export.allow
         when :echo, ExportValueSource::ECHO
-          command_result, exportable, new_lines = ux_block_eval_for_export(
+          command_result = ux_block_eval_for_export(
             bash_script_lines,
             export,
             data: export.echo,
@@ -5118,18 +5213,15 @@ module MarkdownExec
             silent: silent
           )
 
-          if command_result.failure?
-            command_result
-          else
-            command_result = CommandResult.new(
-              stdout: menu_from_list_with_back(
-                command_result.stdout.split("\n")
-              )
+          if command_result.success?
+            command_result.exportable = true
+            command_result.stdout = menu_from_list_with_back(
+              com_exp_cod.command_result.stdout.split("\n")
             )
           end
 
         when :exec, UxActSource::EXEC
-          command_result, exportable, new_lines = ux_block_eval_for_export(
+          command_result = ux_block_eval_for_export(
             bash_script_lines,
             export,
             data: export.exec,
@@ -5138,19 +5230,19 @@ module MarkdownExec
             silent: silent
           )
 
-          if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
+          if command_result.exit_status ==
+             CommandResult::EXIT_STATUS_REQUIRED_EMPTY
             command_result
           else
-            command_result = CommandResult.new(
-              stdout: menu_from_list_with_back(
-                command_result.stdout.split("\n")
-              )
+            command_result.exportable = true
+            command_result.stdout = menu_from_list_with_back(
+              command_result.stdout.split("\n")
             )
           end
 
         else
           export_init = menu_from_list_with_back(export.allow)
-          command_result, exportable, new_lines = ux_block_eval_for_export(
+          command_result = ux_block_eval_for_export(
             [assign_key_value_in_bash(export.name, export_init)],
             export,
             data: export.echo,
@@ -5160,11 +5252,13 @@ module MarkdownExec
             silent: silent,
             string: export_init
           )
-
+          if command_result.success?
+            command_result.exportable = true
+          end
         end
 
       when :echo, UxActSource::ECHO
-        command_result, exportable, new_lines = ux_block_eval_for_export(
+        command_result = ux_block_eval_for_export(
           bash_script_lines,
           export,
           data: export.echo,
@@ -5172,6 +5266,9 @@ module MarkdownExec
           printf_expand: true,
           silent: silent
         )
+        if command_result.success?
+          command_result.exportable = true
+        end
 
       when :edit, UxActSource::EDIT
         output = ''
@@ -5188,7 +5285,6 @@ module MarkdownExec
           end
         rescue Interrupt
           exportable = false
-          transformable = false
         end
 
         if exportable
@@ -5197,29 +5293,35 @@ module MarkdownExec
                          text: output }
         end
         command_result = CommandResult.new(stdout: output)
+        if command_result.success?
+          command_result.exportable = true
+        end
 
       when :exec, UxActSource::EXEC
-        command_result, exportable, new_lines = ux_block_eval_for_export(
+        command_result = ux_block_eval_for_export(
           bash_script_lines,
           export,
           data: export.exec,
           force: force,
           silent: silent
         )
+        if command_result.success?
+          command_result.exportable = true
+        end
 
       else
-        transformable = false
         command_result = CommandResult.new(stdout: export.default.to_s)
+        if command_result.success?
+          command_result.exportable = true
+        end
       end
 
       # add message for required variables
-      if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
+      if command_result.exit_status == CommandResult::EXIT_STATUS_REQUIRED_EMPTY
         command_result.warning = warning_required_empty(export)
         warn command_result.warning unless silent
       end
 
-      command_result.exportable = exportable
-      command_result.transformable = transformable
       command_result.new_lines = new_lines
       command_result
     rescue StandardError
@@ -5232,22 +5334,21 @@ module MarkdownExec
       command_result = nil
       exportable = true
       force = export.force.nil? ? false : export.force
-      new_lines = []
       silent = true
-      transformable = true
 
       case FCB.init_source(export)
       when false, UxActSource::FALSE
         exportable = false
-        transformable = false
-        command_result = CommandResult.new
+        command_result = CommandResult.new(
+          exportable: false
+        )
 
       when :allow, UxActSource::ALLOW
         raise unless export.allow.present?
 
         case export.allow
         when :echo, ExportValueSource::ECHO
-          cr_echo, = ux_block_eval_for_export(
+          cr_echo = ux_block_eval_for_export(
             bash_script_lines,
             export,
             data: export.echo,
@@ -5258,7 +5359,7 @@ module MarkdownExec
           )
           export_init = cr_echo.stdout.split("\n").first
 
-          command_result, exportable, new_lines = ux_block_eval_for_export(
+          command_result = ux_block_eval_for_export(
             [assign_key_value_in_bash(export.name, export_init)],
             export,
             data: export.echo,
@@ -5271,7 +5372,7 @@ module MarkdownExec
 
         when :exec, ExportValueSource::EXEC
           # extract first line from 'exec' output
-          command_result, exportable, new_lines = ux_block_eval_for_export(
+          command_result = ux_block_eval_for_export(
             bash_script_lines,
             export,
             data: export.exec,
@@ -5279,10 +5380,9 @@ module MarkdownExec
             force: force,
             silent: silent
           )
-
           unless command_result.failure?
             export_init = command_result.stdout.split("\n").first
-            command_result, exportable, new_lines = ux_block_eval_for_export(
+            command_result = ux_block_eval_for_export(
               [assign_key_value_in_bash(export.name, export_init)],
               export,
               data: export.exec,
@@ -5296,7 +5396,7 @@ module MarkdownExec
         else
           # first item from 'allow' list
           export_init = export.allow.first
-          command_result, exportable, new_lines = ux_block_eval_for_export(
+          command_result = ux_block_eval_for_export(
             [assign_key_value_in_bash(export.name, export_init)],
             export,
             data: export.allow,
@@ -5309,13 +5409,14 @@ module MarkdownExec
         end
 
       when :default, UxActSource::DEFAULT
-        transformable = false
-        command_result = CommandResult.new(stdout: export.default.to_s)
+        command_result = CommandResult.new(
+          stdout: export.default.to_s
+        )
 
       when :echo, UxActSource::ECHO
         raise unless export.echo.present?
 
-        command_result, exportable, new_lines = ux_block_eval_for_export(
+        command_result = ux_block_eval_for_export(
           bash_script_lines,
           export,
           data: export.echo,
@@ -5327,7 +5428,7 @@ module MarkdownExec
       when :exec, UxActSource::EXEC
         raise unless export.exec.present?
 
-        command_result, exportable, new_lines = ux_block_eval_for_export(
+        command_result = ux_block_eval_for_export(
           bash_script_lines,
           export,
           data: export.exec,
@@ -5337,7 +5438,7 @@ module MarkdownExec
 
       else
         export_init = export.init.to_s
-        command_result, exportable, new_lines = ux_block_eval_for_export(
+        command_result = ux_block_eval_for_export(
           [assign_key_value_in_bash(export.name, export_init)],
           export,
           data: export.exec,
@@ -5349,17 +5450,15 @@ module MarkdownExec
       end
 
       # add message for required variables
-      if command_result.exit_status == EXIT_STATUS_REQUIRED_EMPTY
+      if command_result.exit_status == CommandResult::EXIT_STATUS_REQUIRED_EMPTY
         command_result.warning = warning_required_empty(export)
         warn command_result.warning unless silent
       end
 
-      command_result.exportable = exportable
-      command_result.transformable = transformable
-      command_result.new_lines = new_lines
+      command_result.exportable = command_result.success? && exportable
       command_result
     rescue StandardError
-      wwe bash_script_lines, export
+      wwe $!, bash_script_lines, export
     end
 
     # true if the variable is exported in a series of evaluations
@@ -5395,10 +5494,10 @@ module MarkdownExec
     end
 
     def vux_edit_inherited
-      edited = edit_text(@dml_link_state.inherited_lines_block)
+      edited = edit_text(@dml_link_state.context_code_block)
       return unless edited
 
-      @dml_link_state.inherited_lines =
+      @dml_link_state.context_code =
         annotate_required_lines(
           'blk:EDIT', edited.split("\n"), block_name: 'EDIT'
         )
@@ -5491,7 +5590,8 @@ module MarkdownExec
 
         elsif block_is_shell(@dml_block_state.block)
           debounce_reset
-          vux_input_and_execute_shell_commands(stream: $stderr, shell: shell)
+          vux_input_and_execute_shell_commands(stream: $stderr,
+                                               shell: @delegate_object[:shell])
           return pause_user_exit ? :break : nil
 
         elsif block_is_view(@dml_block_state.block)
@@ -5617,7 +5717,7 @@ module MarkdownExec
     def vux_load_code_files_into_state
       return unless @menu_base_options[:load_code].present?
 
-      @dml_link_state.inherited_lines =
+      @dml_link_state.context_code =
         @menu_base_options[:load_code].split(':').map do |path|
           File.readlines(path, chomp: true)
         end.flatten(1)
@@ -5628,7 +5728,7 @@ module MarkdownExec
 
       pop_add_current_code_to_head_and_trigger_load(
         @dml_link_state, inherited_block_names,
-        code_lines, inherited_dependencies, selected
+        transient_code, inherited_dependencies, selected
       )
     end
 
@@ -5637,7 +5737,7 @@ module MarkdownExec
         document_name_in_glob_as_file_name
       ))
 
-      @dml_link_state.inherited_lines_append(
+      @dml_link_state.context_code_append(
         File.readlines(filespec, chomp: true)
       )
     end
@@ -5796,7 +5896,7 @@ module MarkdownExec
       files = document_glob ? Dir.glob(document_glob) : []
       @doc_saved_lines_files = files.count.positive? ? files : []
 
-      lines_count = @dml_link_state.inherited_lines_count
+      lines_count = @dml_link_state.context_code_count
 
       # add menu items (glob, load, save) and enable selectively
       if files.count.positive? || lines_count.positive?
@@ -5921,7 +6021,7 @@ module MarkdownExec
     end
 
     def vux_view_inherited(stream:)
-      stream.puts @dml_link_state.inherited_lines_block
+      stream.puts @dml_link_state.context_code_block
     end
 
     def wait_for_stream_processing
@@ -5992,6 +6092,10 @@ module MarkdownExec
       determine_block_state(selected_option)
     end
 
+    def warning_failure(export)
+      "A value must exist for: #{export.required.join(', ')}"
+    end
+
     def warning_required_empty(export)
       "A value must exist for: #{export.required.join(', ')}"
     end
@@ -6010,7 +6114,7 @@ module MarkdownExec
           prefix: @delegate_object[:saved_script_filename_prefix],
           saved_asset_format:
             shell_escape_asset_format(
-              code_lines: @dml_link_state.inherited_lines,
+              transient_code: @dml_link_state.context_code,
               shell: shell
             ),
           time: time_now
@@ -6069,7 +6173,7 @@ module MarkdownExec
         if save_filespec.present?
           File.write(
             save_filespec,
-            HashDelegator.join_code_lines(link_state&.inherited_lines)
+            HashDelegator.join_code_lines(link_state&.context_code)
           )
           @delegate_object[:filename]
         else
@@ -6252,7 +6356,7 @@ module MarkdownExec
         LinkState.new(block_name: 'sample_block',
                       document_filename: 'sample_file',
                       inherited_dependencies: {},
-                      inherited_lines: ['# ', 'KEY="VALUE"'])
+                      context_code: ['# ', 'KEY="VALUE"'])
       )
       assert_equal expected_result,
                    @hd.execute_block_type_link_with_state(
@@ -6428,12 +6532,43 @@ module MarkdownExec
     def test_execute_block_type_port_code_lines_with_vars
       YAML.stubs(:load).returns({ 'key' => 'value' })
       @mdoc.stubs(:collect_recursively_required_code)
-           .returns({ code: ['code line'] })
+           .returns({ context_code: [], transient_code: ['code line'] })
       result = @hd.execute_block_type_port_code_lines(
         mdoc: @mdoc, selected: @selected, block_source: {}
       )
 
-      assert_equal ['code line', 'key="value"'], result
+      assert_equal ['key="value"'], result[:context_code]
+      assert_equal ['code line'], result[:transient_code]
+    end
+
+    def test_transient_code_parameter_usage
+      # Test that transient_code parameter is used correctly in execute_bash_script_lines
+      transient_code = ["echo 'test'", "echo 'transient'"]
+      export = OpenStruct.new(exportable: false, validate: //, transform: ->(x) { x })
+      result = HashDelegator.execute_bash_script_lines(
+        transient_code: transient_code,
+        export: export,
+        export_name: 'TEST',
+        shell: '/bin/bash'
+      )
+
+      assert result.is_a?(CommandResult)
+      assert_equal transient_code, result.script
+    end
+
+    def test_transient_code_vs_context_code_separation
+      # Test that transient_code is separate from context_code
+      context_code = ['CONTEXT_VAR="context_value"']
+      transient_code = ['TRANSIENT_VAR="transient_value"']
+
+      # Simulate combining them
+      all_code = HashDelegator.flatten_and_compact_arrays(
+        context_code, transient_code
+      )
+
+      assert_equal 2, all_code.length
+      assert_includes all_code, 'CONTEXT_VAR="context_value"'
+      assert_includes all_code, 'TRANSIENT_VAR="transient_value"'
     end
   end
 
@@ -7211,12 +7346,16 @@ module MarkdownExec
     def setup
       @hd = HashDelegator.new
       @bash_script_lines = ['#!/bin/bash', 'set -e']
-      @export = OpenStruct.new(name: 'TEST_VAR', required: ['TEST_VAR'])
+      @export = OpenStruct.new(
+        name: 'TEST_VAR', required: ['TEST_VAR'], init: 'default'
+      )
       @mock_result = OpenStruct.new(
-        exit_status: 0,
-        stdout: 'test_output',
-        stderr: '',
-        warning: nil
+        command_result: OpenStruct.new(
+          exit_status: 0,
+          stdout: 'test_output',
+          stderr: '',
+          warning: nil
+        )
       )
     end
 
@@ -7229,29 +7368,27 @@ module MarkdownExec
 
     # Test string input - typical case
     def test_string_input_success
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
       @hd.stubs(:variable_is_exportable).returns(true)
 
-      result = @hd.ux_block_eval_for_export(
-        @bash_script_lines, @export,
+      command_result = @hd.ux_block_eval_for_export(
+        @bash_script_lines,
+        @export,
         data: 'echo "hello"',
         force: false,
         silent: false
       )
 
-      command_result, exportable, new_lines = result
-      assert_equal @mock_result, command_result
-      assert_equal true, exportable
-      assert_equal 1, new_lines.length
-      assert_equal 'TEST_VAR', new_lines.first[:name]
-      assert_equal 'test_output', new_lines.first[:text]
+      # assert_equal @mock_result, command_result
+      assert_equal 1, command_result.new_lines.length
+      assert_equal 'TEST_VAR', command_result.new_lines.first[:name]
+      assert_equal "hello\n", command_result.stdout
     end
 
     # Test string input with printf_expand
     def test_string_input_with_printf_expand
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
 
       @hd.ux_block_eval_for_export(
@@ -7268,198 +7405,180 @@ module MarkdownExec
 
     # Test integer input
     def test_integer_input
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: 42,
         force: true,
         silent: false
       )
 
-      command_result, exportable, new_lines = result
       assert_equal @mock_result, command_result
-      assert_equal true, exportable
-      assert_equal 1, new_lines.length
+      assert_equal 1, command_result.new_lines.length
     end
 
     # Test boolean inputs
     def test_boolean_true_input
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: true,
         force: false,
         silent: false
       )
 
-      command_result, exportable, = result
       assert_equal @mock_result, command_result
-      assert_equal true, exportable
     end
 
     def test_boolean_false_input
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: false,
         force: false,
         silent: false
       )
 
-      command_result, exportable, = result
       assert_equal @mock_result, command_result
-      assert_equal true, exportable
     end
 
     # Test float input
     def test_float_input
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: 3.14,
         force: false,
         silent: false
       )
 
-      command_result, exportable, = result
       assert_equal @mock_result, command_result
-      assert_equal true, exportable
     end
 
     # Test hash input - typical case
     def test_hash_input_success
       hash_data = { 'VAR1' => 'value1', 'VAR2' => 'value2' }
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
       @hd.stubs(:code_line_to_assign_a_variable).returns('VAR1=value1')
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: hash_data,
         force: false,
         silent: false
       )
 
-      command_result, exportable, new_lines = result
       assert_equal @mock_result, command_result
-      assert_equal true, exportable
-      assert_equal 2, new_lines.length
-      assert_equal 'VAR1', new_lines.first[:name]
-      assert_equal 'VAR2', new_lines.last[:name]
+      assert_equal 2, command_result.new_lines.length
+      assert_equal 'VAR1', command_result.new_lines.first[:name]
+      assert_equal 'VAR2', command_result.new_lines.last[:name]
     end
 
     # Test hash input with first_only flag
     def test_hash_input_first_only
       hash_data = { 'VAR1' => 'value1', 'VAR2' => 'value2' }
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
-      @hd.stubs(:variable_is_exportable).returns(true)
-      @hd.stubs(:code_line_to_assign_a_variable).returns('VAR1=value1')
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: hash_data,
         first_only: true,
         force: false,
+        printf_expand: true,
         silent: false
       )
 
-      command_result, _, new_lines = result
-      assert_equal @mock_result, command_result
-      assert_equal 1, new_lines.length
-      assert_equal 'VAR1', new_lines.first[:name]
+      assert_equal 1, command_result.new_lines.length
+      assert_equal 'VAR1', command_result.new_lines.first[:name]
     end
 
     # Test hash with non-exportable variables
     def test_hash_input_non_exportable_variables
       hash_data = { 'LOCAL_VAR' => 'value1' }
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      @mock_result.new_lines = []
+      HashDelegator.stubs(:execute_bash_script_lines).returns(@mock_result)
       @hd.stubs(:variable_is_exportable).returns(false)
       @hd.stubs(:code_line_to_assign_a_variable).returns('LOCAL_VAR=value1')
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: hash_data,
         force: false,
         silent: false
       )
 
-      command_result, _, new_lines = result
       assert_equal @mock_result, command_result
-      assert_equal 0, new_lines.length # No exportable variables
+      assert_equal 0, command_result.new_lines.length # No exportable variables
     end
 
     # Test EXIT_STATUS_REQUIRED_EMPTY handling
     def test_exit_status_required_empty_with_warning
-      failed_result = OpenStruct.new(
-        exit_status: 248, # EXIT_STATUS_REQUIRED_EMPTY
+      failed_result = CommandResult.new(
+        exit_status: CommandResult::EXIT_STATUS_REQUIRED_EMPTY,
+        exportable: false,
         stdout: '',
         stderr: 'Required variable empty',
         warning: nil
       )
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([failed_result,
-                                                              false])
+      HashDelegator.stubs(:execute_bash_script_lines).returns(failed_result)
       @hd.stubs(:warning_required_empty).returns('Warning: required empty')
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: 'echo ""',
         force: false,
         silent: false
       )
 
-      command_result, exportable, new_lines = result
       assert_equal failed_result, command_result
-      assert_equal false, exportable
-      assert_equal 0, new_lines.length
       assert_equal 'Warning: required empty', command_result.warning
     end
 
     # Test EXIT_STATUS_REQUIRED_EMPTY handling with silent flag
     def test_exit_status_required_empty_silent
-      failed_result = OpenStruct.new(
-        exit_status: 248,
-        stdout: '',
-        stderr: 'Required variable empty',
-        warning: nil
-      )
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([failed_result,
-                                                              false])
-
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: 'echo ""',
         force: false,
         silent: true
       )
 
-      command_result, exportable, = result
-      assert_equal failed_result, command_result
-      assert_equal false, exportable
-      assert_nil command_result.warning # No warning when silent
+      assert_empty command_result.warning # No warning when silent
     end
 
     # Test string parameter override
     def test_string_parameter_override
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: 'original_data',
         string: 'override_string',
@@ -7468,136 +7587,115 @@ module MarkdownExec
       )
 
       # The function should use string parameter instead of data
-      command_result, exportable, = result
       assert_equal @mock_result, command_result
-      assert_equal true, exportable
     end
 
     # Edge case: empty string
     def test_empty_string_input
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: '',
         force: false,
         silent: false
       )
 
-      command_result, exportable, = result
       assert_equal @mock_result, command_result
-      assert_equal true, exportable
     end
 
     # Edge case: nil data (uses string.nil? check)
     def test_nil_data_input
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
+      @mock_result.exportable = true
+      HashDelegator.stubs(:execute_bash_script_lines).returns(
+        @mock_result
+      )
       @hd.stubs(:variable_is_exportable).returns(true)
 
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: 'd1',
         force: false,
         silent: false
       )
 
-      command_result, exportable, = result
       assert_equal @mock_result, command_result
-      assert_equal true, exportable
     end
 
     # Edge case: empty hash
     def test_empty_hash_input
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: {},
         force: false,
         silent: false
       )
 
-      command_result, exportable, new_lines = result
       assert_nil command_result # No iterations, so command_result remains nil
-      assert_equal true, exportable # Initial value
-      assert_equal 0, new_lines.length
     end
 
     # Edge case: hash with nil values
     def test_hash_with_nil_values
       hash_data = { 'VAR1' => nil, 'VAR2' => 'value2' }
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
-      @hd.stubs(:variable_is_exportable).returns(true)
-      @hd.stubs(:code_line_to_assign_a_variable).returns('VAR1=')
-
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: hash_data,
         force: false,
+        printf_expand: true,
         silent: false
       )
 
-      command_result, exportable, new_lines = result
-      assert_equal @mock_result, command_result
-      assert_equal true, exportable
-      assert_equal 2, new_lines.length
+      assert_equal 2, command_result.new_lines.length
     end
 
     # Edge case: unsupported input type (Array)
     def test_unsupported_input_type_array
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: %w[item1 item2],
         force: false,
         silent: false
       )
 
-      command_result, exportable, new_lines = result
       assert_nil command_result # No processing for unsupported types
-      assert_equal true, exportable # Initial value
-      assert_equal 0, new_lines.length
     end
 
     # Edge case: unsupported input type (custom object)
     def test_unsupported_input_type_object
       custom_object = Object.new
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: custom_object,
         force: false,
         silent: false
       )
 
-      command_result, exportable, new_lines = result
       assert_nil command_result # No processing for unsupported types
-      assert_equal true, exportable # Initial value
-      assert_equal 0, new_lines.length
     end
 
     # Test error handling - StandardError rescue
     def test_standard_error_rescue
       # Should not raise, but return nil due to rescue block
-      result = @hd.ux_block_eval_for_export(
+      command_result = @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
         data: 'test_data',
         force: false,
         silent: false
       )
 
-      command_result, = result
-      assert_equal 127, command_result.exit_status
+      assert_equal CommandResult::EXIT_STATUS_FAIL, command_result.exit_status
     end
 
     # Test environment variable setting
     def test_environment_variable_setting
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
       @hd.stubs(:variable_is_exportable).returns(true)
 
       # Mock EnvInterface.set to verify it's called
-      EnvInterface.expects(:set).with('TEST_VAR', 'test_output')
+      EnvInterface.expects(:set).with('TEST_VAR', "test\n")
 
       @hd.ux_block_eval_for_export(
         @bash_script_lines, @export,
@@ -7609,10 +7707,6 @@ module MarkdownExec
 
     # Test join_array_of_arrays is called correctly
     def test_join_array_of_arrays_called
-      @hd.stubs(:output_from_adhoc_bash_script_file).returns([@mock_result,
-                                                              true])
-      @hd.stubs(:variable_is_exportable).returns(true)
-
       # Mock join_array_of_arrays to verify it's called with correct parameters
       @hd.expects(:join_array_of_arrays).with(
         @bash_script_lines,