odin-foundation 1.0.4 → 1.2.0

data/lib/odin/transform/transform_engine.rb

@@ -8,6 +8,7 @@ module Odin
 
       class TransformError < StandardError
         attr_reader :code
+        attr_accessor :segment, :field
 
         def initialize(message, code: "E001")
           @code = code
@@ -15,6 +16,33 @@ module Odin
         end
       end
 
+      # A warning carrying a stable transform error code. Collected alongside
+      # string warnings; consumers that inspect codes read `.code`.
+      class TransformWarning
+        attr_reader :code, :message
+        attr_accessor :segment, :field
+
+        def initialize(message, code:)
+          @message = message
+          @code = code
+        end
+
+        def to_s
+          @message
+        end
+      end
+
+      # Raised during expression evaluation to carry a coded TransformError up to
+      # the mapping handler, which preserves the code under fail/warn.
+      class CodedTransformError < StandardError
+        attr_reader :transform_error
+
+        def initialize(transform_error)
+          @transform_error = transform_error
+          super(transform_error.message)
+        end
+      end
+
       # ── Transform Error Codes ──
       # T001-T010 are reserved for core transform errors.
       # T011+ are for implementation-specific errors.
@@ -30,6 +58,26 @@ module Odin
         T009_LOOP_SOURCE_NOT_ARRAY   = "T009"
         T010_POSITION_OVERFLOW       = "T010"
         T011_INCOMPATIBLE_CONVERSION = "T011"
+        T012_DANGLING_BRANCH         = "T012"
+        T014_NESTED_INTERPOLATION    = "T014"
+      end
+
+      # Create a T014 Nested Interpolation error.
+      def self.nested_interpolation_error(expr, segment = nil)
+        err = TransformError.new(
+          "Nested interpolation is not allowed: ${#{expr}}",
+          code: ErrorCodes::T014_NESTED_INTERPOLATION
+        )
+        err.segment = segment if segment
+        err
+      end
+
+      # Create a T012 Dangling Branch error (elif/else with no preceding if).
+      def self.dangling_branch_error(directive)
+        TransformError.new(
+          "'#{directive}' segment has no preceding 'if'",
+          code: ErrorCodes::T012_DANGLING_BRANCH
+        )
       end
 
       # Create a T011 Incompatible Conversion error.
@@ -42,13 +90,56 @@ module Odin
         )
       end
 
+      # Create a T001 Unknown Verb error.
+      def self.unknown_verb_error(verb_name)
+        TransformError.new("Unknown verb: #{verb_name}", code: ErrorCodes::T001_UNKNOWN_VERB)
+      end
+
+      # Create a T003 Lookup Table Not Found error.
+      def self.lookup_table_not_found_error(table_name)
+        TransformError.new("Lookup table not found: #{table_name}", code: ErrorCodes::T003_LOOKUP_TABLE_NOT_FOUND)
+      end
+
+      # Create a T004 Lookup Key Not Found error.
+      def self.lookup_key_not_found_error(table_name, key)
+        TransformError.new("Lookup key '#{key}' not found in table '#{table_name}'", code: ErrorCodes::T004_LOOKUP_KEY_NOT_FOUND)
+      end
+
+      # Create a T005 Source Path Not Found error.
+      def self.source_path_not_found_error(path)
+        TransformError.new("Source path not found: #{path}", code: ErrorCodes::T005_SOURCE_PATH_NOT_FOUND)
+      end
+
+      # Create a T006 Invalid Output Format error.
+      def self.invalid_output_format_error(format)
+        TransformError.new("Invalid or unsupported output format: #{format}", code: ErrorCodes::T006_INVALID_OUTPUT_FORMAT)
+      end
+
+      # Create a T008 Accumulator Overflow error.
+      def self.accumulator_overflow_error(name, value)
+        TransformError.new("Accumulator '#{name}' overflow with value #{value}", code: ErrorCodes::T008_ACCUMULATOR_OVERFLOW)
+      end
+
+      # Create a T009 Loop Source Not Array error.
+      def self.loop_source_not_array_error(path)
+        TransformError.new("Loop source path '#{path}' does not resolve to an array", code: ErrorCodes::T009_LOOP_SOURCE_NOT_ARRAY)
+      end
+
+      # The required-source-missing code: a present-but-null :required field.
+      SOURCE_MISSING = "SOURCE_MISSING"
+
       attr_reader :verb_registry
 
       def initialize
         @verb_registry = build_verb_registry
       end
 
-      def execute(transform_def, source_data)
+      def execute(transform_def, source_data, import_resolver: nil)
+        # Merge imported tables, constants, accumulators, and segments.
+        if import_resolver && transform_def.imports && !transform_def.imports.empty?
+          resolve_imports(transform_def, import_resolver)
+        end
+
         # Check for multi-record mode (discriminator dispatch)
         disc_config = transform_def.discriminator_config
         if disc_config
@@ -71,9 +162,7 @@ module Odin
         passes = transform_def.passes
         if passes.empty?
           # Single implicit pass
-          transform_def.segments.each do |segment|
-            process_segment(segment, source, context, output)
-          end
+          process_segment_list(transform_def.segments, source, context, output)
         else
           # Multi-pass: explicit passes first, then pass-0 (implicit)
           all_passes = passes.include?(0) ? passes : passes + [0]
@@ -84,12 +173,8 @@ module Odin
             end
             first_pass = false
 
-            transform_def.segments.each do |segment|
-              seg_pass = segment.pass || 0
-              next unless seg_pass == pass_num
-
-              process_segment(segment, source, context, output)
-            end
+            pass_segments = transform_def.segments.select { |s| (s.pass || 0) == pass_num }
+            process_segment_list(pass_segments, source, context, output)
           end
         end
 
@@ -107,7 +192,7 @@ module Odin
         # 7. Convert output to plain Ruby for result (DynValues -> native Ruby)
         plain_output = deep_to_ruby(output)
 
-        TransformResult.new(output: plain_output, formatted: formatted, output_dv: output_dv, errors: context.errors)
+        TransformResult.new(output: plain_output, formatted: formatted, output_dv: output_dv, errors: context.errors, warnings: context.warnings)
       end
 
       # ── Multi-Record Execution (discriminator-based routing) ──
@@ -203,7 +288,7 @@ module Odin
         # Convert output to plain Ruby
         plain_output = deep_to_ruby(output)
 
-        TransformResult.new(output: plain_output, formatted: formatted, output_dv: output_dv, errors: context.errors)
+        TransformResult.new(output: plain_output, formatted: formatted, output_dv: output_dv, errors: context.errors, warnings: context.warnings)
       end
 
       private def parse_discriminator_config(config)
@@ -275,17 +360,47 @@ module Odin
       # Public for unit testing verbs directly
       def invoke_verb(name, args, context)
         verb_fn = @verb_registry[name]
-        raise TransformError.new("Unknown verb: %#{name}") unless verb_fn
+        raise CodedTransformError.new(self.class.unknown_verb_error(name)) unless verb_fn
 
         verb_fn.call(args, context)
       end
 
+      # Verbs whose leading arguments must be numeric; checked under strictTypes.
+      NUMERIC_ARG_VERBS = %w[
+        sqrt abs round floor ceil negate sign trunc ln log log10 log2 exp pow
+        add subtract multiply divide mod between formatNumber formatInteger
+        formatCurrency toRadians toDegrees
+      ].freeze
+
+      NUMERIC_DYN_TYPES = %i[integer float float_raw currency currency_raw percent null].freeze
+
+      # T002: under strictTypes, a numeric verb argument that is not a numeric
+      # (or null) value fails the field.
+      def check_verb_arg_types!(verb_name, args)
+        return unless NUMERIC_ARG_VERBS.include?(verb_name)
+
+        args.each_with_index do |arg, i|
+          next if arg.nil?
+          next if NUMERIC_DYN_TYPES.include?(arg.type)
+
+          err = TransformError.new(
+            "Verb '#{verb_name}' arg #{i + 1}: expected number, got #{arg.type}",
+            code: ErrorCodes::T002_INVALID_VERB_ARGS
+          )
+          raise CodedTransformError.new(err)
+        end
+      end
+
       # ── Expression Evaluation ──
 
       def evaluate(expr, context)
         case expr
         when LiteralExpr
-          expr.value
+          val = expr.value
+          if val.is_a?(Types::DynValue) && val.string? && val.value.include?("${")
+            return interpolate_string(val.value, context)
+          end
+          val
         when CopyExpr
           val = resolve_path(expr.source_path, context)
           # Apply CopyExpr-level extraction directives only for compatible source formats
@@ -308,15 +423,71 @@ module Odin
 
       private
 
-      # Emulate JavaScript's signed 32-bit right shift (>>).
-      # Ruby integers are arbitrary precision and always do logical (unsigned) shift,
-      # but JS >> sign-extends from bit 31.
+      # Merge imported lookup tables, constants, accumulators, and named segments
+      # into this transform. Local declarations win over imported ones; imported
+      # segments are appended so their mappings remain referenceable.
+      def resolve_imports(transform_def, resolver)
+        seen = {}
+        transform_def.imports.each do |path|
+          next if seen[path]
+
+          seen[path] = true
+          text = resolver.call(path)
+          next if text.nil?
+
+          imported = TransformParser.new.parse(text)
+
+          imported.tables.each do |name, table|
+            transform_def.tables[name] = table unless transform_def.tables.key?(name)
+          end
+          imported.constants.each do |name, value|
+            transform_def.constants[name] = value unless transform_def.constants.key?(name)
+          end
+          imported.accumulators.each do |name, acc_def|
+            transform_def.accumulators[name] = acc_def unless transform_def.accumulators.key?(name)
+          end
+
+          existing_names = transform_def.segments.map(&:name)
+          imported.segments.each do |seg|
+            next if seg.name.to_s.empty? || existing_names.include?(seg.name)
+
+            transform_def.segments << seg
+          end
+        end
+      end
+
+      # Signed 32-bit right shift (>>) with sign-extension from bit 31.
+      # Ruby integers are arbitrary precision and always do logical (unsigned) shift.
       def js_signed_rshift(val, shift)
         val = val & 0xFFFFFFFF
         val -= 0x100000000 if val >= 0x80000000
         (val >> shift) & 0xFF
       end
 
+      # Extract a [key, value] pair from a %toObject entry in either
+      # pair-array ([k, v]) or {key, value} / {k, v} object form.
+      def to_object_pair(item)
+        return nil unless item.is_a?(Types::DynValue)
+
+        if item.array?
+          items = item.value || []
+          return nil if items.length < 2
+          return [items[0].to_string, items[1]]
+        end
+
+        if item.object?
+          entries = item.value || {}
+          if entries.key?("key") && entries.key?("value")
+            return [entries["key"].to_string, entries["value"]]
+          end
+          if entries.key?("k") && entries.key?("v")
+            return [entries["k"].to_string, entries["v"]]
+          end
+        end
+
+        nil
+      end
+
       def deep_to_ruby(obj)
         case obj
         when Types::DynValue
@@ -417,7 +588,8 @@ module Odin
         when Types::OdinBoolean then Types::DynValue.of_bool(val.value)
         when Types::OdinNull then Types::DynValue.of_null
         when Types::OdinCurrency
-          Types::DynValue.of_currency(val.value, val.respond_to?(:decimal_places) ? val.decimal_places : 2)
+          Types::DynValue.of_currency(val.value, val.respond_to?(:decimal_places) ? val.decimal_places : 2,
+                                      val.respond_to?(:currency_code) ? val.currency_code : nil)
         when Types::OdinReference then Types::DynValue.of_reference(val.path)
         when Types::OdinBinary then Types::DynValue.of_binary(val.data)
         else Types::DynValue.of_null
@@ -430,6 +602,13 @@ module Odin
         context = VerbContext.new
         context.source = source
         context.source_format = transform_def.source_format || ""
+        ov = transform_def.header.target_options["onValidation"]
+        context.on_validation = ov if ov && !ov.empty?
+        om = transform_def.header.target_options["onMissing"]
+        context.on_missing = om if om && !om.empty?
+        oe = transform_def.header.target_options["onError"]
+        context.on_error = oe if oe && !oe.empty?
+        context.strict_types = transform_def.header.strict_types
 
         # Initialize constants
         transform_def.constants.each do |key, val|
@@ -449,6 +628,34 @@ module Odin
         context
       end
 
+      # Report a missing lookup key (T004) honoring the on_missing policy.
+      # Defaults to silent null; raises only when on_missing is fail/warn.
+      def report_lookup_miss(context, table_name, key)
+        case context.on_missing
+        when "fail"
+          context.errors << self.class.lookup_key_not_found_error(table_name, key)
+        when "warn"
+          context.warnings << TransformWarning.new(
+            "Lookup key '#{key}' not found in table '#{table_name}'",
+            code: ErrorCodes::T004_LOOKUP_KEY_NOT_FOUND
+          )
+        end
+      end
+
+      # Report a missing lookup table (T003) honoring the on_missing policy.
+      # Distinct from a missing key (T004): the referenced table was never declared.
+      def report_table_not_found(context, table_name)
+        case context.on_missing
+        when "fail"
+          context.errors << self.class.lookup_table_not_found_error(table_name)
+        when "warn"
+          context.warnings << TransformWarning.new(
+            "Lookup table not found: #{table_name}",
+            code: ErrorCodes::T003_LOOKUP_TABLE_NOT_FOUND
+          )
+        end
+      end
+
       def reset_non_persist_accumulators(context, accumulator_defs)
         accumulator_defs.each do |key, acc_def|
           next if acc_def.persist
@@ -459,6 +666,52 @@ module Odin
 
       # ── Segment Processing ──
 
+      # Process a list of segments, honoring if/elif/else conditional chains.
+      # A chain is a run of consecutive segments: one `if`, then any `elif`, then
+      # an optional `else`. Only the first branch whose condition holds is emitted.
+      def process_segment_list(segments, source, context, output)
+        # :none = no active chain; :pending = chain open, none taken; :taken = a branch taken
+        branch = :none
+
+        segments.each do |segment|
+          if segment.if_condition
+            taken = evaluate_condition(segment.if_condition, source, context)
+            branch = taken ? :taken : :pending
+            process_segment(segment, source, context, output) if taken
+          elsif segment.elif_condition
+            if branch == :none
+              context.errors << self.class.dangling_branch_error("elif")
+              next
+            end
+            next if branch == :taken
+
+            taken = evaluate_condition(segment.elif_condition, source, context)
+            branch = taken ? :taken : :pending
+            process_segment(segment, source, context, output) if taken
+          elsif segment.is_else
+            if branch == :none
+              context.errors << self.class.dangling_branch_error("else")
+              next
+            end
+            process_segment(segment, source, context, output) if branch == :pending
+            branch = :none
+          else
+            branch = :none
+            process_segment(segment, source, context, output)
+          end
+        end
+      end
+
+      # A segment whose name begins with "_" is a computation-only sink:
+      # it runs for side effects (accumulators, verbs) and is never emitted.
+      def sink_segment?(segment)
+        name = segment.name.to_s
+        return false if name.empty?
+
+        last = name.split(".").last || name
+        last.start_with?("_")
+      end
+
       def process_segment(segment, source, context, output, modifier_prefix: "")
         # Check _when condition
         if segment.when_condition
@@ -483,6 +736,12 @@ module Odin
         seg_name = segment.name
         full_prefix = modifier_prefix.empty? ? seg_name : "#{modifier_prefix}.#{seg_name}"
 
+        # Literal block: emit interpolated text lines instead of field mappings.
+        if segment.is_literal
+          process_literal_segment(segment, source, context, output)
+          return
+        end
+
         # Handle _each (loop over array)
         if segment.each_source
           process_loop_segment(segment, source, context, output, modifier_prefix: full_prefix)
@@ -500,6 +759,9 @@ module Odin
           process_segment(child, source, context, segment_result, modifier_prefix: full_prefix)
         end
 
+        # Sink section: side effects only, nothing emitted.
+        return if sink_segment?(segment)
+
         # Merge segment result into output
         if segment_result.any?
           if segment.is_array && segment.array_index
@@ -528,84 +790,325 @@ module Odin
         end
       end
 
-      def process_loop_segment(segment, source, context, output, modifier_prefix: "")
-        # Resolve the array to iterate
-        each_path = segment.each_source
-        items = resolve_path_from_string(each_path, source, context)
+      # Render a :literal segment to interpolated text lines. Under a :loop the
+      # block renders once per item; lines are emitted verbatim by the formatter.
+      def process_literal_segment(segment, source, context, output)
+        template = segment.literal_body.to_s
+        lines = []
+        render = lambda do |ctx|
+          render_literal(template, ctx, segment.path).split("\n", -1).each { |l| lines << l }
+        end
 
-        # If the resolved value is null (path not found), skip iteration
-        # matching TypeScript which checks Array.isArray(items)
-        if items.is_a?(Types::DynValue) && items.null?
-          return
+        if (segment.loops && !segment.loops.empty?) || segment.each_source
+          loops = segment_loops(segment)
+          dummy = []
+          begin
+            iterate_loops(loops, 0, segment, source, context, dummy, on_item: render)
+          rescue CodedTransformError => e
+            coded = e.transform_error
+            coded.segment = segment.name
+            case context.on_error
+            when "warn"
+              context.warnings << TransformWarning.new(coded.message, code: coded.code).tap { |w| w.segment = segment.name }
+            when "skip"
+              # drop silently
+            else
+              context.errors << coded
+            end
+          end
+        else
+          render.call(context)
         end
 
-        # If the resolved value is not an array, wrap single non-null values
-        if items.is_a?(Types::DynValue) && !items.array?
-          items = Types::DynValue.of_array([items])
+        set_output_path(output, segment.name, { "__literalLines" => lines })
+      end
+
+      def render_literal(template, context, segment_path)
+        interpolate_literal_block(template, context)
+      rescue TransformError => e
+        if e.code == ErrorCodes::T014_NESTED_INTERPOLATION
+          e.segment ||= segment_path
+          context.errors << e
+          ""
+        else
+          raise
         end
+      end
 
-        return unless items.is_a?(Types::DynValue) && items.array?
+      # Interpolate ${...} in a literal block body. Escapes: \${ -> ${, \$ -> $,
+      # \\ -> \. A ${...} whose expression contains another ${ is a T014 error.
+      def interpolate_literal_block(template, context)
+        out = +""
+        i = 0
+        len = template.length
+        while i < len
+          ch = template[i]
+          if ch == "\\"
+            nxt = template[i + 1]
+            if nxt == "$" && template[i + 2] == "{"
+              out << "${"; i += 3; next
+            elsif nxt == "\\"
+              out << "\\"; i += 2; next
+            elsif nxt == "$"
+              out << "$"; i += 2; next
+            else
+              out << "\\"; i += 1; next
+            end
+          end
 
-        # Check if this is a scalar array loop (only has _ = expr mappings)
-        has_underscore_only = segment.field_mappings.all? { |m| m.target_field == "_" } &&
-                              segment.field_mappings.any? && segment.children.empty?
+          if ch == "$" && template[i + 1] == "{"
+            close = template.index("}", i + 2)
+            if close.nil?
+              out << template[i..]
+              break
+            end
+            expr = template[(i + 2)...close]
+            raise TransformEngine.nested_interpolation_error(expr) if expr.include?("${")
+            out << evaluate_interpolation_expr(expr.strip, context)
+            i = close + 1
+            next
+          end
+
+          out << ch
+          i += 1
+        end
+        out
+      end
+
+      def evaluate_interpolation_expr(expr, context)
+        if expr.start_with?("%")
+          parser = TransformParser.new
+          parsed, = parser.send(:parse_expr_from_tokens, parser.send(:tokenize_expression, expr))
+          parsed ? dynvalue_string(evaluate(parsed, context)) : "${#{expr}}"
+        elsif expr.start_with?("@")
+          dynvalue_string(resolve_path(expr[1..], context))
+        else
+          "${#{expr}}"
+        end
+      end
 
+      def process_loop_segment(segment, source, context, output, modifier_prefix: "")
+        loops = segment_loops(segment)
         results = []
+        begin
+          iterate_loops(loops, 0, segment, source, context, results, modifier_prefix: modifier_prefix)
+        rescue CodedTransformError => e
+          coded = e.transform_error
+          coded.segment = segment.name
+          case context.on_error
+          when "warn"
+            context.warnings << TransformWarning.new(coded.message, code: coded.code).tap { |w| w.segment = segment.name }
+          when "skip"
+            # drop silently
+          else
+            context.errors << coded
+          end
+          return
+        end
+
+        return if sink_segment?(segment)
+
+        seg_name = segment.name
+        # Always set the array in output, even if empty
+        set_output_path(output, seg_name, results)
+      end
+
+      # Normalize a segment's loop directives to a list of {source:, alias:} specs.
+      def segment_loops(segment)
+        if segment.loops && !segment.loops.empty?
+          segment.loops
+        else
+          [{ source: segment.each_source, alias: nil }]
+        end
+      end
+
+      # Drive one or more :loop directives as a nested cross-product. Each level
+      # binds its alias and current item, then recurses; the innermost level emits
+      # one element per item. A non-array source at any level yields no rows.
+      def iterate_loops(loops, depth, segment, source, context, results, modifier_prefix: "", on_item: nil)
         loop_ctx = context.dup_for_loop
         raise TransformError.new("Maximum loop nesting depth exceeded") if loop_ctx.loop_depth > VerbContext::MAX_LOOP_DEPTH
 
+        spec = loops[depth]
+        is_outermost = depth.zero?
+        is_innermost = depth == loops.length - 1
+
+        items = resolve_loop_items(spec[:source], is_outermost, source, context)
+        unless items.is_a?(Types::DynValue) && items.array?
+          # A present non-array scalar is a T009 error; an absent/null source
+          # yields zero rows silently.
+          if items.is_a?(Types::DynValue) && !items.null?
+            raise CodedTransformError.new(self.class.loop_source_not_array_error(spec[:source].to_s))
+          end
+          return
+        end
+
+        has_underscore_only = segment.field_mappings.all? { |m| m.target_field == "_" } &&
+                              segment.field_mappings.any? && segment.children.empty?
+
         items.value.each_with_index do |item, idx|
-          loop_ctx.current_item = item
-          loop_ctx.loop_index = idx
-          loop_ctx.loop_length = items.value.length
-          loop_ctx.loop_vars["_item"] = item
-          loop_ctx.loop_vars["_index"] = Types::DynValue.of_integer(idx)
-          loop_ctx.loop_vars["_length"] = Types::DynValue.of_integer(items.value.length)
+          item_ctx = loop_ctx.dup_for_loop
+          item_ctx.loop_depth = loop_ctx.loop_depth
+          item_ctx.current_item = item
+          item_ctx.loop_index = idx
+          item_ctx.loop_length = items.value.length
+          item_ctx.loop_vars["_item"] = item
+          item_ctx.loop_vars["_index"] = Types::DynValue.of_integer(idx)
+          item_ctx.loop_vars["_length"] = Types::DynValue.of_integer(items.value.length)
+          item_ctx.aliases[spec[:alias]] = item if spec[:alias]
 
-          if segment.counter_name
-            loop_ctx.loop_vars[segment.counter_name] = Types::DynValue.of_integer(idx)
+          # :counter binds the innermost index and resets per outer item.
+          if segment.counter_name && is_innermost
+            item_ctx.loop_vars[segment.counter_name] = Types::DynValue.of_integer(idx)
+          end
+
+          unless is_innermost
+            iterate_loops(loops, depth + 1, segment, item, item_ctx, results,
+                          modifier_prefix: modifier_prefix, on_item: on_item)
+            next
+          end
+
+          if on_item
+            on_item.call(item_ctx)
+            next
           end
 
           if has_underscore_only
-            # Scalar array: evaluate the _ mapping and use the result as the array element
             val = Types::DynValue.of_null
             segment.field_mappings.each do |mapping|
-              val = evaluate(mapping.expression, loop_ctx)
-              # Apply extraction directives first (:pos, :len, :field) as a group
+              val = evaluate(mapping.expression, item_ctx)
               val = apply_extraction_directives(val, mapping.directives)
-              # Apply remaining directives
               mapping.directives.each do |directive|
                 next if %w[pos len field].include?(directive.name)
-                val = apply_directive(val, directive, item, loop_ctx)
+                val = apply_directive(val, directive, item, item_ctx)
               end
             end
             results << val
           else
             item_result = {}
             segment.field_mappings.each do |mapping|
-              process_mapping(mapping, item, loop_ctx, item_result, modifier_prefix: modifier_prefix)
+              process_mapping(mapping, item, item_ctx, item_result, modifier_prefix: modifier_prefix)
             end
-
-            # Process children
             segment.children.each do |child|
-              process_segment(child, item, loop_ctx, item_result, modifier_prefix: modifier_prefix)
+              process_segment(child, item, item_ctx, item_result, modifier_prefix: modifier_prefix)
             end
-
             results << item_result if item_result.any?
           end
         end
+      end
 
-        seg_name = segment.name
-        # Always set the array in output, even if empty (Java parity)
-        set_output_path(output, seg_name, results)
+      # Resolve the array for a loop level. Outermost resolves against the source
+      # root; inner levels resolve relative (.field) or aliased paths against the
+      # current item.
+      def resolve_loop_items(path, is_outermost, source, context)
+        p = path.to_s
+        p = p[1..] if p.start_with?("@")
+
+        items = if p.start_with?(".")
+                  base = context.in_loop? && context.current_item ? context.current_item : source
+                  resolve_dotted_path(base, p[1..])
+                elsif is_outermost
+                  resolve_path_from_string(p, source, context)
+                else
+                  first = p.split(".").first
+                  if context.aliases.key?(first)
+                    aliased = context.aliases[first]
+                    rest = p.include?(".") ? p[(first.length + 1)..] : ""
+                    rest.empty? ? aliased : resolve_dotted_path(aliased, rest)
+                  else
+                    base = context.in_loop? && context.current_item ? context.current_item : source
+                    resolve_dotted_path(base, p)
+                  end
+                end
+
+        items
+      end
+
+      # Precompiled :validate / :enum / :range data for a mapping.
+      CompiledValidation = Struct.new(
+        :pattern, :regex, :regex_error,
+        :enum_allowed, :enum_label,
+        :range_str, :range_min, :range_max,
+        keyword_init: true
+      )
+
+      # Per-mapping directive references and flags, derived once from the mapping's
+      # data-independent directives/modifiers and reused across all executions.
+      MappingMods = Struct.new(
+        :if_dir, :unless_dir, :object_dir,
+        :has_default, :has_raw, :has_array,
+        :extraction_dir_names, :required,
+        :validate_dir, :enum_dir, :range_dir,
+        :validation, :validation_active,
+        keyword_init: true
+      )
+
+      # Build (or reuse) the precomputed modifier data for a mapping, memoized on
+      # the mapping object so the directive list is scanned only once.
+      def mapping_mods(mapping)
+        cached = mapping.instance_variable_get(:@__mods)
+        return cached if cached
+
+        directives = mapping.directives
+        validate_dir = directives.find { |d| d.name == "validate" }
+        enum_dir = directives.find { |d| d.name == "enum" }
+        range_dir = directives.find { |d| d.name == "range" }
+
+        mods = MappingMods.new(
+          if_dir: directives.find { |d| d.name == "if" },
+          unless_dir: directives.find { |d| d.name == "unless" },
+          object_dir: directives.find { |d| d.name == "object" },
+          has_default: directives.any? { |d| d.name == "default" },
+          has_raw: directives.any? { |d| d.name == "raw" },
+          has_array: directives.any? { |d| d.name == "array" },
+          extraction_dir_names: directives.map(&:name) & %w[pos len field trim],
+          required: mapping.modifiers.include?(FieldModifier::REQUIRED),
+          validate_dir: validate_dir,
+          enum_dir: enum_dir,
+          range_dir: range_dir,
+          validation: compile_validation(validate_dir, enum_dir, range_dir),
+          validation_active: !validate_dir.nil? || !enum_dir.nil? || !range_dir.nil?
+        )
+        mapping.instance_variable_set(:@__mods, mods)
+        mods
+      end
+
+      # Precompile the regex / enum set / range bounds for validation directives.
+      def compile_validation(validate_dir, enum_dir, range_dir)
+        cv = CompiledValidation.new
+
+        if validate_dir && !validate_dir.value.nil?
+          cv.pattern = validate_dir.value.to_s
+          begin
+            cv.regex = Regexp.new(cv.pattern)
+          rescue RegexpError
+            cv.regex_error = true
+          end
+        end
+
+        if enum_dir && !enum_dir.value.nil?
+          allowed = enum_dir.value.to_s.split(",").map { |v| v.strip.gsub(/\A["']|["']\z/, "") }
+          cv.enum_allowed = allowed
+          cv.enum_label = allowed.join(", ")
+        end
+
+        if range_dir && !range_dir.value.nil?
+          cv.range_str = range_dir.value.to_s
+          parts = cv.range_str.split("..")
+          cv.range_min = (Float(parts[0]) rescue nil)
+          cv.range_max = (Float(parts[1]) rescue nil)
+        end
+
+        cv
       end
 
       def process_mapping(mapping, source, context, output, modifier_prefix: "")
         target = mapping.target_field
 
-        # Handle _pass directive and other underscore-prefixed targets
-        # but still evaluate `_` (bare underscore) for side effects like accumulate
-        if target == "_"
+        # An unrecognized `_`-prefixed target is a computation-only sink: it runs
+        # for side effects (accumulators, counters) but is never emitted. This
+        # lets several %accumulate/%set advance in one loop pass.
+        if target.start_with?("_")
           begin
             evaluate(mapping.expression, context)
           rescue StandardError => e
@@ -613,38 +1116,106 @@ module Odin
           end
           return
         end
-        return if target.start_with?("_")
 
         begin
-          # Evaluate expression
-          # Extraction directives (pos, len, field, trim) only apply for extraction-compatible
-          # source formats. For output formats like fixed-width, these directives are used by
-          # the formatter for positioning, NOT for input extraction.
-          src_fmt = context.source_format
-          extraction_compatible = %w[fixed-width csv delimited flat].include?(src_fmt)
-          has_extraction = extraction_compatible &&
-            mapping.directives.any? { |d| %w[pos len field trim].include?(d.name) }
-
-          # Check if CopyExpr already has its own extraction directives
-          # (applied during evaluate() for compatible source formats)
-          expr_has_own_extraction = extraction_compatible && expr_has_extraction_directives?(mapping.expression)
-
-          if has_extraction && mapping.expression.is_a?(VerbExpr) && !expr_has_own_extraction
-            # For verb expressions with extraction directives, apply extraction
-            # to the first CopyExpr argument before calling the verb (matching Java behavior)
-            val = evaluate_verb_with_extraction(mapping.expression, context, mapping.directives)
+          mods = mapping_mods(mapping)
+
+          # Field-level :if / :unless gate the assignment on a comparison expression.
+          if_dir = mods.if_dir
+          if if_dir
+            return unless evaluate_condition(if_dir.value.to_s, source, context)
+          end
+          unless_dir = mods.unless_dir
+          if unless_dir
+            return if evaluate_condition(unless_dir.value.to_s, source, context)
+          end
+
+          # A :default modifier handles a missing lookup; suppress errors raised during evaluation.
+          has_default = mods.has_default
+          errors_before = has_default ? context.errors.length : 0
+
+          # :object builds a nested object from an inline {key = @path, …} spec.
+          object_dir = mods.object_dir
+          if object_dir
+            val = build_inline_object(object_dir.value.to_s, context)
           else
-            val = evaluate(mapping.expression, context)
-            # Apply extraction directives only if expression doesn't handle its own extraction
-            if has_extraction && !expr_has_own_extraction
-              val = apply_extraction_directives(val, mapping.directives)
+            # Evaluate expression
+            # Extraction directives (pos, len, field, trim) only apply for extraction-compatible
+            # source formats. For output formats like fixed-width, these directives are used by
+            # the formatter for positioning, NOT for input extraction.
+            src_fmt = context.source_format
+            extraction_compatible = %w[fixed-width csv delimited flat].include?(src_fmt)
+            has_extraction = extraction_compatible &&
+              mapping.directives.any? { |d| %w[pos len field trim].include?(d.name) }
+
+            # Check if CopyExpr already has its own extraction directives
+            # (applied during evaluate() for compatible source formats)
+            expr_has_own_extraction = extraction_compatible && expr_has_extraction_directives?(mapping.expression)
+
+            if has_extraction && mapping.expression.is_a?(VerbExpr) && !expr_has_own_extraction
+              # For verb expressions with extraction directives, apply extraction
+              # to the first CopyExpr argument before calling the verb
+              val = evaluate_verb_with_extraction(mapping.expression, context, mapping.directives)
+            else
+              val = evaluate(mapping.expression, context)
+              # Apply extraction directives only if expression doesn't handle its own extraction
+              if has_extraction && !expr_has_own_extraction
+                val = apply_extraction_directives(val, mapping.directives)
+              end
             end
+
+            # Apply remaining directives (non-extraction: type, default, upper, lower, etc.)
+            mapping.directives.each do |directive|
+              next if %w[pos len field trim if unless object raw array cdata validate enum range].include?(directive.name)
+              val = apply_directive(val, directive, source, context)
+            end
+          end
+
+          # If a :default rescued a null result, drop errors raised during evaluation.
+          if has_default && context.errors.length > errors_before
+            context.errors.slice!(errors_before..)
+          end
+
+          # Validation modifiers: :validate / :enum / :range (honors onValidation policy).
+          return unless validate_field_value(val, mapping, context)
+
+          # :raw emits inline JSON structurally instead of an escaped string.
+          if mods.has_raw
+            val = parse_raw_json_value(val)
           end
 
-          # Apply remaining directives (non-extraction: type, default, upper, lower, etc.)
-          mapping.directives.each do |directive|
-            next if %w[pos len field trim].include?(directive.name)
-            val = apply_directive(val, directive, source, context)
+          # :array wraps the value in a single-element array.
+          if mods.has_array
+            val = Types::DynValue.of_array([val.is_a?(Types::DynValue) ? val : Types::DynValue.from_ruby(val)])
+          end
+
+          # Missing source path: a :required field always fails (T005); an ordinary
+          # field honors the onMissing policy (fail -> T005, warn -> warning,
+          # skip/default -> keep null). A path that is merely null is not "missing".
+          required = mods.required
+          val_null = val.is_a?(Types::DynValue) && val.null?
+          if val_null && copy_source_absent?(mapping, source, context)
+            raw_path = mapping.expression.is_a?(CopyExpr) ? mapping.expression.source_path : target
+            path = raw_path.to_s.start_with?(".") ? raw_path[1..] : raw_path.to_s
+            if required
+              context.errors << self.class.source_path_not_found_error(path)
+              return
+            end
+            case context.on_missing
+            when "fail"
+              context.errors << self.class.source_path_not_found_error(path)
+              return
+            when "warn"
+              context.warnings << TransformWarning.new(
+                "Source path not found: #{path}", code: ErrorCodes::T005_SOURCE_PATH_NOT_FOUND
+              )
+            end
+          elsif required && val_null
+            # Required field present but explicitly null.
+            context.errors << TransformError.new(
+              "Required field '#{target}' is missing or null", code: SOURCE_MISSING
+            )
+            return
           end
 
           # Track field modifiers with full path
@@ -656,9 +1227,87 @@ module Odin
           # Store DynValue directly to preserve type information (date, timestamp, etc.)
           dv_val = val.is_a?(Types::DynValue) ? val : Types::DynValue.from_ruby(val)
           set_path(output, target, dv_val)
+        rescue CodedTransformError => e
+          # Coded errors carry a stable T-code; preserve it under fail/warn.
+          coded = e.transform_error
+          coded.field = target
+          case context.on_error
+          when "warn"
+            context.warnings << TransformWarning.new(coded.message, code: coded.code).tap { |w| w.field = target }
+          when "skip"
+            # drop silently
+          else
+            context.errors << coded
+          end
         rescue StandardError => e
-          context.errors << TransformError.new(e.message)
+          case context.on_error
+          when "warn"
+            context.warnings << e.message
+          when "skip"
+            # drop silently
+          else
+            context.errors << TransformError.new(e.message)
+          end
+        end
+      end
+
+      # Whether a mapping copies a source path that is absent (undefined) — distinct
+      # from a path present with a null value. Only plain copy expressions qualify;
+      # verbs, literals, objects, and special paths are never "missing source".
+      def copy_source_absent?(mapping, source, context)
+        expr = mapping.expression
+        return false unless expr.is_a?(CopyExpr)
+        # A :default / :object modifier supplies its own fallback.
+        return false if mapping.directives.any? { |d| %w[default object].include?(d.name) }
+
+        path = expr.source_path.to_s
+        return false if path.empty? || path.start_with?("$") || path == "_index"
+        return false if context.loop_vars.key?(path)
+
+        base = source.is_a?(Types::DynValue) ? source : context.source
+        if path.start_with?(".")
+          base = context.current_item if context.in_loop? && context.current_item
+          target_path = path[1..]
+        else
+          first = path.split(".").first
+          if context.aliases.key?(first)
+            base = context.aliases[first]
+            target_path = path.include?(".") ? path[(first.length + 1)..] : ""
+          else
+            target_path = path
+          end
         end
+
+        resolved = target_path.to_s.empty? ? base : resolve_dotted_path(base, target_path)
+        # resolve_dotted_path collapses both absent and explicit-null to of_null; an
+        # absent path is one whose leaf key is not explicitly present.
+        return false unless resolved.is_a?(Types::DynValue) && resolved.null?
+
+        !path_present?(base, target_path)
+      end
+
+      # True when target_path resolves to an explicitly-present key (even if its
+      # value is null); false when any segment along the path is missing.
+      def path_present?(base, target_path)
+        return true if target_path.to_s.empty?
+        return false unless base.is_a?(Types::DynValue)
+
+        segments = parse_path_segments(target_path)
+        current = base
+        segments.each do |seg|
+          return false unless current.is_a?(Types::DynValue)
+
+          if seg.is_a?(Integer)
+            return false unless current.array? && seg < current.value.length
+
+            current = current.get_index(seg)
+          else
+            return false unless current.object? && current.value.key?(seg)
+
+            current = current.get(seg)
+          end
+        end
+        true
       end
 
       # ── Path Assignment (nested object creation for dotted paths) ──
@@ -736,7 +1385,11 @@ module Odin
 
         if path.start_with?("$accumulator.") || path.start_with?("$accumulators.")
           key = path.sub(/\A\$(?:accumulator|accumulators)\./, "")
-          return context.get_accumulator(key)
+          acc = context.get_accumulator(key)
+          return acc unless acc.null?
+          # Loop counters declared via :counter are also readable through the accumulator reference.
+          return context.loop_vars[key] if context.loop_vars.key?(key)
+          return acc
         end
 
         # _index, _length loop vars
@@ -750,6 +1403,10 @@ module Odin
           return context.loop_vars[path]
         end
 
+        # A leading :loop :as alias resolves against its bound item.
+        aliased = resolve_via_alias(path, context)
+        return aliased unless aliased.nil?
+
         # Determine source to navigate
         current_source = if context.in_loop? && context.current_item
                            context.current_item
@@ -761,6 +1418,19 @@ module Odin
         resolve_dotted_path(current_source, path)
       end
 
+      # When the first dotted segment names a :loop alias, resolve the remainder
+      # against the bound item. Returns nil when the path is not alias-led.
+      def resolve_via_alias(path, context)
+        return nil unless context.respond_to?(:aliases) && context.aliases && !context.aliases.empty?
+
+        first = path.split(".").first
+        return nil unless context.aliases.key?(first)
+
+        aliased = context.aliases[first]
+        rest = path.include?(".") ? path[(first.length + 1)..] : ""
+        rest.empty? ? aliased : resolve_dotted_path(aliased, rest)
+      end
+
       def resolve_path_from_string(path_str, source, context)
         return source if path_str.nil? || path_str.empty?
 
@@ -773,6 +1443,10 @@ module Odin
             return context.in_loop? && context.current_item ? context.current_item : source
           end
 
+          # A leading :loop :as alias resolves against its bound item.
+          aliased = resolve_via_alias(sub_path, context)
+          return aliased unless aliased.nil?
+
           current_source = if context.in_loop? && context.current_item
                              context.current_item
                            else
@@ -858,17 +1532,10 @@ module Odin
         verb_name = expr.verb_name
         args = expr.arguments
 
-        # Lazy evaluation for conditional verbs — apply extraction to result
-        case verb_name
-        when "ifElse"
-          val = evaluate_if_else(args, context)
-          return apply_extraction_directives(val, extraction_directives)
-        when "cond"
-          val = evaluate_cond(args, context)
-          return apply_extraction_directives(val, extraction_directives)
-        when "switch"
-          val = evaluate_switch(args, context)
-          return apply_extraction_directives(val, extraction_directives)
+        # Lazy evaluation for control-flow verbs — apply extraction to result.
+        if !context.strict_types && LAZY_VERBS.include?(verb_name) && !(expr.respond_to?(:custom) && expr.custom)
+          handled, val = evaluate_lazy_verb(verb_name, args, context)
+          return apply_extraction_directives(val, extraction_directives) if handled
         end
 
         # Eager evaluation: apply extraction directives to CopyExpr arguments
@@ -905,18 +1572,19 @@ module Odin
         invoke_verb(verb_name, evaluated_args, context)
       end
 
+      # Control-flow verbs that evaluate the condition first and run only the
+      # selected branch; and/or/coalesce short-circuit. Strict-types mode
+      # evaluates eagerly so every argument is validated.
+      LAZY_VERBS = %w[ifElse ifNull ifEmpty coalesce and or cond switch].freeze
+
       def evaluate_verb(expr, context)
         verb_name = expr.verb_name
         args = expr.arguments
 
-        # Lazy evaluation for conditional verbs
-        case verb_name
-        when "ifElse"
-          return evaluate_if_else(args, context)
-        when "cond"
-          return evaluate_cond(args, context)
-        when "switch"
-          return evaluate_switch(args, context)
+        # Lazy evaluation for control-flow verbs (skipped under strict types).
+        if !context.strict_types && LAZY_VERBS.include?(verb_name) && !(expr.respond_to?(:custom) && expr.custom)
+          handled, value = evaluate_lazy_verb(verb_name, args, context)
+          return value if handled
         end
 
         # Eager evaluation for all other verbs
@@ -935,10 +1603,58 @@ module Odin
           return evaluated_args.first || Types::DynValue.of_null
         end
 
+        # T002: enforce verb argument types under strictTypes.
+        if context.strict_types
+          check_verb_arg_types!(verb_name, evaluated_args)
+        end
+
         # Look up and invoke verb
         invoke_verb(verb_name, evaluated_args, context)
       end
 
+      # Dispatch a lazy control-flow verb. Returns [handled, value]; handled is
+      # false when arity is too low, so the caller falls back to eager paths.
+      def evaluate_lazy_verb(verb_name, args, context)
+        ev = ->(i) { evaluate(args[i], context) }
+        case verb_name
+        when "ifElse"
+          return [false, Types::DynValue.of_null] if args.length < 3
+          [true, ev.call(0).truthy? ? ev.call(1) : ev.call(2)]
+        when "ifNull"
+          return [false, Types::DynValue.of_null] if args.length < 2
+          v0 = ev.call(0)
+          [true, v0.null? ? ev.call(1) : v0]
+        when "ifEmpty"
+          return [false, Types::DynValue.of_null] if args.length < 2
+          v0 = ev.call(0)
+          [true, lazy_empty?(v0) ? ev.call(1) : v0]
+        when "coalesce"
+          args.each_index do |i|
+            v = ev.call(i)
+            return [true, v] unless v.null?
+          end
+          [true, Types::DynValue.of_null]
+        when "and"
+          return [false, Types::DynValue.of_null] if args.length < 2
+          return [true, Types::DynValue.of_bool(false)] unless ev.call(0).truthy?
+          [true, Types::DynValue.of_bool(ev.call(1).truthy?)]
+        when "or"
+          return [false, Types::DynValue.of_null] if args.length < 2
+          return [true, Types::DynValue.of_bool(true)] if ev.call(0).truthy?
+          [true, Types::DynValue.of_bool(ev.call(1).truthy?)]
+        when "cond"
+          [true, evaluate_cond(args, context)]
+        when "switch"
+          [true, evaluate_switch(args, context)]
+        else
+          [false, Types::DynValue.of_null]
+        end
+      end
+
+      def lazy_empty?(v)
+        v.nil? || v.null? || (v.string? && v.value.empty?)
+      end
+
       def evaluate_if_else(args, context)
         return Types::DynValue.of_null if args.length < 3
 
@@ -1009,17 +1725,37 @@ module Odin
           return increment
         end
 
-        # Numeric accumulation
-        new_val = Types::DynValue.of_float(current.to_number + increment.to_number)
-        # Preserve integer type if both are integers
-        if current.integer? && increment.integer?
-          new_val = Types::DynValue.of_integer(current.to_number + increment.to_number)
+        sum = current.to_number + increment.to_number
+
+        # T008: the result exceeds representable numeric capacity (non-finite, or
+        # an integer accumulator beyond the safe-integer magnitude where precision
+        # is lost). Retain the last valid value.
+        if accumulator_overflow?(current, sum)
+          context.errors << self.class.accumulator_overflow_error(name, sum)
+          return current
         end
 
+        # Preserve integer type if both are integers
+        new_val = if current.integer? && increment.integer?
+                    Types::DynValue.of_integer(sum)
+                  else
+                    Types::DynValue.of_float(sum.to_f)
+                  end
+
         context.set_accumulator(name, new_val)
         new_val
       end
 
+      # The largest integer that survives a double round-trip (2^53 - 1).
+      MAX_SAFE_INTEGER = 9_007_199_254_740_991
+
+      def accumulator_overflow?(current, sum)
+        f = sum.to_f
+        return true if f.nan? || f.infinite?
+
+        current.integer? && sum.abs > MAX_SAFE_INTEGER
+      end
+
       def handle_set(raw_args, evaluated_args, context)
         return Types::DynValue.of_null if raw_args.length < 2
 
@@ -1099,8 +1835,9 @@ module Odin
         elsif str.match?(/\A-?\d+\.\d+\z/)
           Types::DynValue.of_float(str.to_f)
         else
-          # Treat as path without @
-          resolve_dotted_path(source.is_a?(Types::DynValue) ? source : context.source, str)
+          # Treat as path without @; an unresolved bare word is a string literal.
+          resolved = resolve_dotted_path(source.is_a?(Types::DynValue) ? source : context.source, str)
+          resolved.is_a?(Types::DynValue) && resolved.null? ? Types::DynValue.of_string(str) : resolved
         end
       end
 
@@ -1350,6 +2087,14 @@ module Odin
       end
 
       def coerce_to_currency(val, dp = 2, currency_code = nil)
+        if val.type == :currency || val.type == :currency_raw
+          existing_dp = val.decimal_places || dp
+          code = currency_code || val.currency_code
+          if val.type == :currency_raw
+            return Types::DynValue.of_currency_raw(val.value, existing_dp, code)
+          end
+          return Types::DynValue.of_currency(val.value.to_f, existing_dp, code)
+        end
         if val.type == :float || val.type == :float_raw
           f = val.to_number.to_f
           formatted = format("%.#{dp}f", f)
@@ -1443,6 +2188,153 @@ module Odin
         end
       end
 
+      # ── Inline Object / Raw JSON / Validation ──
+
+      # Build a structural object from an inline ":object {key = @path, …}" spec.
+      def build_inline_object(spec, context)
+        trimmed = spec.strip.sub(/\A\{/, "").sub(/\}\z/, "")
+        entries = {}
+        unless trimmed.strip.empty?
+          split_object_pairs(trimmed).each do |pair|
+            eq = pair.index("=")
+            next unless eq
+
+            key = pair[0...eq].strip
+            rhs = pair[(eq + 1)..].strip
+            next if key.empty?
+
+            expr, = TransformParser.new.parse_expression_string(rhs)
+            entries[key] = evaluate(expr, context)
+          end
+        end
+        Types::DynValue.of_object(entries)
+      end
+
+      # Split an inline-object body on commas not nested inside braces.
+      def split_object_pairs(body)
+        pairs = []
+        depth = 0
+        current = +""
+        body.each_char do |ch|
+          depth += 1 if ch == "{"
+          depth -= 1 if ch == "}"
+          if ch == "," && depth.zero?
+            pairs << current
+            current = +""
+          else
+            current << ch
+          end
+        end
+        pairs << current unless current.strip.empty?
+        pairs
+      end
+
+      # Parse a string value as JSON for :raw, producing a structural DynValue.
+      def parse_raw_json_value(val)
+        return val unless val.is_a?(Types::DynValue) && val.string?
+
+        begin
+          Types::DynValue.from_ruby(JSON.parse(val.value))
+        rescue StandardError
+          val
+        end
+      end
+
+      # Validate a value against :validate / :enum / :range directives.
+      # Returns false when the field should be dropped (onValidation = skip / fail).
+      def validate_field_value(val, mapping, context)
+        return true if val.is_a?(Types::DynValue) && val.null?
+
+        cv = mapping_mods(mapping).validation
+        policy = context.on_validation || "fail"
+        failures = []
+
+        if cv.pattern
+          str = dynvalue_string(val)
+          if cv.regex_error
+            failures << "invalid validation pattern '#{cv.pattern}'"
+          elsif !cv.regex.match?(str)
+            failures << "value '#{str}' does not match pattern '#{cv.pattern}'"
+          end
+        end
+
+        if cv.enum_allowed
+          str = dynvalue_string(val)
+          failures << "value '#{str}' is not one of [#{cv.enum_label}]" unless cv.enum_allowed.include?(str)
+        end
+
+        if cv.range_str
+          num = numeric_of(val)
+          if num.nil?
+            failures << "value '#{dynvalue_string(val)}' is not numeric for range #{cv.range_str}"
+          elsif (cv.range_min && num < cv.range_min) || (cv.range_max && num > cv.range_max)
+            failures << "value #{num} is outside range #{cv.range_str}"
+          end
+        end
+
+        return true if failures.empty?
+
+        message = "Validation failed for '#{mapping.target_field}': #{failures.join('; ')}"
+        case policy
+        when "warn"
+          # Warn but still emit.
+          true
+        when "skip"
+          false
+        else
+          context.errors << TransformError.new(message, code: "T013")
+          false
+        end
+      end
+
+      def numeric_of(val)
+        return nil unless val.is_a?(Types::DynValue)
+
+        case val.type
+        when :integer, :float, :float_raw, :currency, :currency_raw, :percent
+          val.to_number.to_f
+        when :string
+          Float(val.value) rescue nil
+        else
+          nil
+        end
+      end
+
+      def dynvalue_string(val)
+        return val.to_s unless val.is_a?(Types::DynValue)
+
+        FormatExporters.send(:dynvalue_to_string, val)
+      end
+
+      MAX_INTERPOLATIONS = 320
+
+      # Interpolate ${...} expressions within a string template.
+      # Supports ${@path}, ${%verb args}, and \${...} (literal ${...}).
+      def interpolate_string(template, context)
+        count = 0
+        result = template.gsub(/\\?\$\{([^}]+)\}/) do
+          match = Regexp.last_match(0)
+          expr = Regexp.last_match(1)
+          count += 1
+          next match if count > MAX_INTERPOLATIONS
+
+          # Escaped \${ — emit a literal ${...}.
+          next "${#{expr}}" if match.start_with?("\\")
+
+          trimmed = expr.strip
+          if trimmed.start_with?("%")
+            parsed, = TransformParser.new.send(:parse_expr_from_tokens,
+                                               TransformParser.new.send(:tokenize_expression, trimmed))
+            parsed ? dynvalue_string(evaluate(parsed, context)) : match
+          elsif trimmed.start_with?("@")
+            dynvalue_string(resolve_path(trimmed[1..], context))
+          else
+            match
+          end
+        end
+        Types::DynValue.of_string(result)
+      end
+
       # ── Object Expression Evaluation ──
 
       def evaluate_object(expr, context)
@@ -1456,10 +2348,36 @@ module Odin
 
       # ── Format Output ──
 
+      # Output formats with a registered formatter. An unrecognized format raises
+      # T006 rather than silently defaulting to JSON.
+      KNOWN_OUTPUT_FORMATS = %w[json odin xml csv fixed-width flat properties].freeze
+
       def format_output(output_dv, transform_def, context = nil)
         target_format = transform_def.target_format
         return nil unless target_format
 
+        unless KNOWN_OUTPUT_FORMATS.include?(target_format)
+          context.errors << self.class.invalid_output_format_error(target_format) if context
+          return ""
+        end
+
+        # T007: positional layout directives (:pos/:len) only apply to fixed-width
+        # output; on any other target they are invalid for the format.
+        if context && target_format != "fixed-width"
+          transform_def.segments.each do |segment|
+            segment.field_mappings.each do |mapping|
+              next unless mapping.directives.any? { |d| %w[pos len].include?(d.name) }
+
+              err = TransformError.new(
+                "Modifier ':pos/:len' is not valid for #{target_format} output",
+                code: ErrorCodes::T007_INVALID_MODIFIER
+              )
+              err.field = mapping.target_field
+              context.errors << err
+            end
+          end
+        end
+
         case target_format
         when "json"
           topts = transform_def.header.target_options
@@ -1488,7 +2406,7 @@ module Odin
           end
           FormatExporters.to_csv(csv_dv, delimiter: delimiter, header: include_header)
         when "fixed-width"
-          format_fixed_width_output(output_dv, transform_def)
+          format_fixed_width_output(output_dv, transform_def, context)
         when "flat", "properties"
           style = transform_def.header.target_options["style"]
           if style == "yaml"
@@ -1502,12 +2420,35 @@ module Odin
         end
       end
 
-      # Format output as fixed-width text (segment-based, matching TypeScript)
-      def format_fixed_width_output(output_dv, transform_def)
-        line_width = 80
+      # Format output as fixed-width text (segment-based)
+      def format_fixed_width_output(output_dv, transform_def, context = nil)
         lw = transform_def.header.target_options["lineWidth"]
-        line_width = lw.to_i if lw && lw.to_i > 0
+        has_line_width = !lw.nil? && parse_target_int(lw, 0) > 0
+        line_width = has_line_width ? parse_target_int(lw, 80) : 80
+
+        # T010: a field whose pos+len exceeds the configured line width overflows.
+        if has_line_width && context
+          transform_def.segments.each do |segment|
+            segment.field_mappings.each do |mapping|
+              pos_dir = mapping.directives.find { |d| d.name == "pos" }
+              len_dir = mapping.directives.find { |d| d.name == "len" }
+              next unless pos_dir && len_dir
+
+              pos = pos_dir.value.to_i
+              len = len_dir.value.to_i
+              next unless pos + len > line_width
+
+              err = TransformError.new(
+                "Field '#{mapping.target_field}' position #{pos} + length #{len} exceeds line width #{line_width}",
+                code: ErrorCodes::T010_POSITION_OVERFLOW
+              )
+              err.field = mapping.target_field
+              context.errors << err
+            end
+          end
+        end
         default_pad = transform_def.header.target_options["padChar"] || " "
+        truncate = transform_def.header.target_options["truncate"] == "true"
         line_ending = transform_def.header.target_options["lineEnding"] || "\n"
 
         lines = []
@@ -1516,16 +2457,22 @@ module Odin
           seg_name = segment.name
           seg_data = resolve_segment_data(output_dv, seg_name)
 
+          literal_lines = extract_literal_lines(seg_data)
+          if literal_lines
+            literal_lines.each { |l| lines << l }
+            next
+          end
+
           if segment.is_array && seg_data.is_a?(Array)
             # Array segment: one line per item
             seg_data.each do |item|
               data = item.is_a?(Types::DynValue) ? dynvalue_to_flat_hash(item) : (item.is_a?(Hash) ? item : {})
-              lines << format_fwf_line(segment.field_mappings, data, line_width, default_pad)
+              lines << format_fwf_line(segment.field_mappings, data, line_width, default_pad, has_line_width, truncate)
             end
           elsif segment.is_array && seg_data.is_a?(Types::DynValue) && seg_data.array?
             seg_data.value.each do |item|
               data = dynvalue_to_flat_hash(item)
-              lines << format_fwf_line(segment.field_mappings, data, line_width, default_pad)
+              lines << format_fwf_line(segment.field_mappings, data, line_width, default_pad, has_line_width, truncate)
             end
           else
             # Single segment: one line
@@ -1536,7 +2483,7 @@ module Odin
                    else
                      dynvalue_to_flat_hash(output_dv)
                    end
-            lines << format_fwf_line(segment.field_mappings, data, line_width, default_pad)
+            lines << format_fwf_line(segment.field_mappings, data, line_width, default_pad, has_line_width, truncate)
           end
         end
 
@@ -1553,6 +2500,16 @@ module Odin
         default_val
       end
 
+      # Returns the verbatim lines of a rendered :literal segment, or nil.
+      def extract_literal_lines(seg_data)
+        return nil unless seg_data.is_a?(Types::DynValue) && seg_data.object?
+
+        marker = seg_data.get("__literalLines")
+        return nil unless marker.is_a?(Types::DynValue) && marker.array?
+
+        marker.value.map { |v| v.is_a?(Types::DynValue) ? v.to_string : v.to_s }
+      end
+
       def resolve_segment_data(output_dv, seg_name)
         return output_dv unless output_dv.is_a?(Types::DynValue) && output_dv.object?
 
@@ -1575,7 +2532,7 @@ module Odin
         result
       end
 
-      def format_fwf_line(mappings, data, line_width, default_pad)
+      def format_fwf_line(mappings, data, line_width, default_pad, has_line_width = false, truncate = false)
         # Sort mappings by :pos for deterministic output
         sorted = mappings.sort_by do |m|
           pos_dir = m.directives.find { |d| d.name == "pos" }
@@ -1638,10 +2595,19 @@ module Odin
           end
         end
 
+        # Pad the record to the configured fixed line width.
+        if has_line_width
+          if line.length < line_width
+            line += default_pad * (line_width - line.length)
+          elsif line.length > line_width && truncate
+            line = line[0...line_width]
+          end
+        end
+
         line
       end
 
-      # ── XML Output Formatting (segment-based, matching TypeScript) ──
+      # ── XML Output Formatting (segment-based) ──
 
       def format_xml_output(output_dv, transform_def, context)
         topts = transform_def.header.target_options
@@ -1650,17 +2616,25 @@ module Odin
         indent_val = topts["indent"]
         indent_size = indent_val ? parse_target_int(indent_val, 2) : 2
         indent_str = " " * indent_size
+        # emitTypeHints=false produces plain XML with no odin: attributes/namespace
+        eth_val = topts["emitTypeHints"]
+        emit_type_hints = eth_val != "false" && eth_val != "?false"
+        namespaces = transform_def.header.target_namespaces || {}
 
         xml = +""
         xml << %{<?xml version="1.0" encoding="UTF-8"?>\n} if include_declaration
 
-        # Collect which fields have :attr directive per segment
+        # Collect per-field :attr, :ns and :cdata directives per segment
         attr_fields = {}
+        ns_fields = {}
+        cdata_fields = {}
         transform_def.segments.each do |segment|
           segment.field_mappings.each do |mapping|
-            if mapping.directives.any? { |d| d.name == "attr" }
-              attr_fields["#{segment.name}.#{mapping.target_field}"] = true
-            end
+            full = "#{segment.name}.#{mapping.target_field}"
+            attr_fields[full] = true if mapping.directives.any? { |d| d.name == "attr" }
+            cdata_fields[full] = true if mapping.directives.any? { |d| d.name == "cdata" }
+            ns_dir = mapping.directives.find { |d| d.name == "ns" }
+            ns_fields[full] = ns_dir.value if ns_dir
           end
         end
 
@@ -1677,7 +2651,9 @@ module Odin
                       []
                     end
             items.each do |item|
-              xml << render_xml_segment_element(seg_name, item, segment, attr_fields, is_array: true, indent_str: indent_str)
+              xml << render_xml_segment_element(seg_name, item, segment, attr_fields, ns_fields, cdata_fields,
+                                                is_array: true, indent_str: indent_str,
+                                                emit_type_hints: emit_type_hints, namespaces: namespaces)
             end
           else
             data = if seg_data.is_a?(Types::DynValue)
@@ -1687,14 +2663,16 @@ module Odin
                    else
                      output_dv
                    end
-            xml << render_xml_segment_element(seg_name, data, segment, attr_fields, is_array: false, indent_str: indent_str)
+            xml << render_xml_segment_element(seg_name, data, segment, attr_fields, ns_fields, cdata_fields,
+                                              is_array: false, indent_str: indent_str,
+                                              emit_type_hints: emit_type_hints, namespaces: namespaces)
           end
         end
 
         xml
       end
 
-      def render_xml_segment_element(seg_name, data, segment, attr_fields, is_array: false, indent_str: "  ")
+      def render_xml_segment_element(seg_name, data, segment, attr_fields, ns_fields, cdata_fields = {}, is_array: false, indent_str: "  ", emit_type_hints: true, namespaces: {})
         return "" unless data.is_a?(Types::DynValue) && data.object?
 
         entries = data.value
@@ -1718,21 +2696,40 @@ module Odin
           end
         end
 
-        # Non-array segments always get xmlns:odin namespace
-        ns = !is_array ? ' xmlns:odin="https://odin.foundation/ns"' : ""
+        # xmlns:odin only when type hints are emitted; omitted on namespaced roots without typed content
+        include_odin_ns = emit_type_hints && !is_array && (namespaces.empty? || has_typed)
+        odin_ns = include_odin_ns ? ' xmlns:odin="https://odin.foundation/ns"' : ""
+        ns_decls = !is_array ? build_xml_namespace_decls(namespaces) : ""
         attrs = attr_parts.empty? ? "" : " #{attr_parts.join(' ')}"
 
-        xml = +"<#{seg_name}#{ns}#{attrs}>\n"
+        xml = +"<#{seg_name}#{odin_ns}#{ns_decls}#{attrs}>\n"
         child_keys.each do |key|
           val = entries[key]
           next unless val
-          type_attr = xml_type_attr(val)
-          xml << "#{indent_str}<#{key}#{type_attr}>#{xml_escape_attr(val_to_xml_string(val))}</#{key}>\n"
+          tag = ns_qualify_xml(key, ns_fields["#{seg_name}.#{key}"])
+          type_attr = emit_type_hints ? xml_type_attr(val) : ""
+          text = if cdata_fields["#{seg_name}.#{key}"]
+                   "<![CDATA[#{val_to_xml_string(val)}]]>"
+                 else
+                   xml_escape_attr(val_to_xml_string(val))
+                 end
+          xml << "#{indent_str}<#{tag}#{type_attr}>#{text}</#{tag}>\n"
         end
         xml << "</#{seg_name}>\n"
         xml
       end
 
+      # Build xmlns:<prefix> declarations for target namespaces in insertion order
+      def build_xml_namespace_decls(namespaces)
+        return "" if namespaces.nil? || namespaces.empty?
+        namespaces.map { |prefix, uri| " xmlns:#{prefix}=\"#{xml_escape_attr(uri)}\"" }.join
+      end
+
+      # Qualify an element name with its namespace prefix when :ns is set
+      def ns_qualify_xml(key, prefix)
+        prefix ? "#{prefix}:#{key}" : key
+      end
+
       def xml_type_attr(dv)
         case dv.type
         when :null then ' odin:type="null"'
@@ -1742,8 +2739,8 @@ module Odin
           v = dv.value.to_f
           v == v.to_i.to_f && v.abs < 1e15 ? ' odin:type="integer"' : ' odin:type="number"'
         when :currency, :currency_raw
-          v = dv.value.to_f
-          v == v.to_i.to_f && v.abs < 1e15 ? ' odin:type="integer"' : ' odin:type="number"'
+          # every currency is first-class; a coded currency also carries its ISO code
+          dv.currency_code ? " odin:type=\"currency\" odin:currencyCode=\"#{dv.currency_code}\"" : ' odin:type="currency"'
         when :percent then ' odin:type="percent"'
         else ""
         end
@@ -1757,8 +2754,12 @@ module Odin
         when :float then FormatExporters.send(:format_number, dv.value)
         when :string then dv.value
         when :currency
-          v = dv.value.to_f
-          v == v.to_i && v.abs < 1e15 ? v.to_i.to_s : v.to_s
+          # render at the value's decimal scale (default 2), preserving precision
+          dp = dv.decimal_places || 2
+          format("%.#{dp}f", dv.value.to_f)
+        when :currency_raw
+          # raw string already carries exact precision
+          dv.value.to_s
         else FormatExporters.send(:dynvalue_to_string, dv)
         end
       end
@@ -1771,6 +2772,31 @@ module Odin
          .gsub("'", "&apos;")
       end
 
+      # True when every backslash escape in a JSON string body is well-formed.
+      def valid_json_escapes?(s)
+        i = 0
+        len = s.length
+        while i < len
+          if s[i] == "\\"
+            i += 1
+            return false if i >= len
+            case s[i]
+            when "\"", "\\", "/", "b", "f", "n", "r", "t"
+              i += 1
+            when "u"
+              hex = s[(i + 1), 4]
+              return false if hex.nil? || hex.length < 4 || hex !~ /\A[0-9a-fA-F]{4}\z/
+              i += 5
+            else
+              return false
+            end
+          else
+            i += 1
+          end
+        end
+        true
+      end
+
       # ── Verb Registry ──
 
       def build_verb_registry
@@ -1787,6 +2813,7 @@ module Odin
         Verbs::AggregationVerbs.register(registry)
         Verbs::ObjectVerbs.register(registry)
         Verbs::GeoVerbs.register(registry)
+        Verbs::ExtraVerbs.register(registry)
 
         registry
       end
@@ -1799,7 +2826,7 @@ module Odin
         registry["capitalize"] = ->(args, _ctx) {
           if args[0]&.string?
             s = args[0].value
-            Types::DynValue.of_string(s.empty? ? s : s[0].upcase + s[1..])
+            Types::DynValue.of_string(s.empty? ? s : s[0].upcase + s[1..].downcase)
           else
             args[0] || Types::DynValue.of_null
           end
@@ -1860,7 +2887,19 @@ module Odin
         # Type checks
         registry["typeOf"] = ->(args, _ctx) {
           v = args[0]
-          type_str = v.nil? ? "null" : v.type.to_s
+          type_str =
+            if v.nil?
+              "null"
+            else
+              {
+                null: "null", bool: "boolean", integer: "integer",
+                float: "number", float_raw: "number", string: "string",
+                array: "array", object: "object", date: "date",
+                timestamp: "timestamp", time: "time", duration: "duration",
+                currency: "currency", currency_raw: "currency", percent: "percent",
+                reference: "reference", binary: "binary"
+              }.fetch(v.type, "unknown")
+            end
           Types::DynValue.of_string(type_str)
         }
         registry["isString"] = ->(args, _ctx) { Types::DynValue.of_bool(args[0]&.string? || false) }
@@ -1872,9 +2911,9 @@ module Odin
 
         # Coercion
         registry["coerceString"] = ->(args, _ctx) { Types::DynValue.of_string(args[0]&.to_string || "") }
-        registry["coerceNumber"] = ->(args, _ctx) { Types::DynValue.of_float(args[0]&.to_number&.to_f || 0.0) }
-        registry["coerceInteger"] = ->(args, _ctx) { Types::DynValue.of_integer(args[0]&.to_number&.to_i || 0) }
-        registry["coerceBoolean"] = ->(args, _ctx) { Types::DynValue.of_bool(args[0]&.truthy? || false) }
+        registry["coerceNumber"] = ->(args, _ctx) { Verbs::NumericVerbs.numeric_result(Verbs::NumericVerbs.to_number(args[0])) }
+        registry["coerceInteger"] = ->(args, _ctx) { Types::DynValue.of_integer(Verbs::NumericVerbs.to_number(args[0]).floor) }
+        registry["coerceBoolean"] = ->(args, _ctx) { Types::DynValue.of_bool(Verbs::NumericVerbs.coerce_boolean(args[0])) }
 
         # Arithmetic
         registry["add"] = ->(args, _ctx) {
@@ -1924,13 +2963,19 @@ module Odin
             ctx.set_accumulator(name, increment)
             increment
           else
-            new_val = if current.integer? && increment.integer?
-                        Types::DynValue.of_integer(current.to_number + increment.to_number)
-                      else
-                        Types::DynValue.of_float(current.to_number.to_f + increment.to_number.to_f)
-                      end
-            ctx.set_accumulator(name, new_val)
-            new_val
+            sum = current.to_number + increment.to_number
+            if accumulator_overflow?(current, sum)
+              ctx.errors << self.class.accumulator_overflow_error(name, sum)
+              current
+            else
+              new_val = if current.integer? && increment.integer?
+                          Types::DynValue.of_integer(sum)
+                        else
+                          Types::DynValue.of_float(sum.to_f)
+                        end
+              ctx.set_accumulator(name, new_val)
+              new_val
+            end
           end
         }
 
@@ -1962,16 +3007,23 @@ module Odin
           table_name = table_ref[0...dot_index]
           return_column = table_ref[(dot_index + 1)..]
 
-          table = ctx.get_table(table_name)
-          return Types::DynValue.of_null unless table
-
           # Get match values (all args after table ref)
           match_values = args[1..].map { |a| a&.to_string || "" }
+          match_key = match_values.join(", ")
+
+          table = ctx.get_table(table_name)
+          unless table
+            report_table_not_found(ctx, table_name)
+            return Types::DynValue.of_null
+          end
 
           # Build list of match columns (all columns except return column)
           columns = table.columns
           return_col_index = columns.index(return_column)
-          return Types::DynValue.of_null unless return_col_index
+          unless return_col_index
+            report_lookup_miss(ctx, table_name, match_key)
+            return Types::DynValue.of_null
+          end
 
           match_col_names = columns.reject { |c| c == return_column }
 
@@ -1993,6 +3045,7 @@ module Odin
             end
           end
 
+          report_lookup_miss(ctx, table_name, match_key)
           Types::DynValue.of_null
         }
 
@@ -2045,15 +3098,23 @@ module Odin
 
         # Sequence
         registry["sequence"] = ->(args, ctx) {
-          name = args[0]&.to_string || "default"
-          val = ctx.next_sequence(name)
-          Types::DynValue.of_integer(val)
+          return Types::DynValue.of_integer(1) if args.empty?
+
+          name = args[0].to_string
+          start_value = args.length > 1 ? (args[1]&.to_number || 1).floor : 1
+          current = ctx.sequences[name]
+          current = current.nil? ? start_value : current + 1
+          ctx.sequences[name] = current
+          Types::DynValue.of_integer(current)
         }
 
         registry["resetSequence"] = ->(args, ctx) {
-          name = args[0]&.to_string || "default"
-          ctx.reset_sequence(name)
-          Types::DynValue.of_integer(0)
+          return Types::DynValue.of_null if args.empty?
+
+          name = args[0].to_string
+          value = args.length > 1 ? (args[1]&.to_number || 0).floor : 0
+          ctx.sequences[name] = value
+          Types::DynValue.of_integer(value)
         }
 
         # Min/Max of variadic
@@ -2140,19 +3201,20 @@ module Odin
           Types::DynValue.of_bool(args[0]&.truthy? || args[1]&.truthy?)
         }
 
-        # Comparison
-        registry["lt"] = ->(args, _ctx) {
-          Types::DynValue.of_bool((args[0]&.to_number || 0) < (args[1]&.to_number || 0))
-        }
-        registry["lte"] = ->(args, _ctx) {
-          Types::DynValue.of_bool((args[0]&.to_number || 0) <= (args[1]&.to_number || 0))
-        }
-        registry["gt"] = ->(args, _ctx) {
-          Types::DynValue.of_bool((args[0]&.to_number || 0) > (args[1]&.to_number || 0))
-        }
-        registry["gte"] = ->(args, _ctx) {
-          Types::DynValue.of_bool((args[0]&.to_number || 0) >= (args[1]&.to_number || 0))
-        }
+        # Comparison: numeric when both coerce to numbers, else lexical.
+        compare = lambda do |a, b|
+          an = Verbs::NumericVerbs.to_double(a)
+          bn = Verbs::NumericVerbs.to_double(b)
+          if !an.nil? && !bn.nil?
+            an <=> bn
+          else
+            (a&.to_string || "") <=> (b&.to_string || "")
+          end
+        end
+        registry["lt"] = ->(args, _ctx) { Types::DynValue.of_bool(compare.call(args[0], args[1]) < 0) }
+        registry["lte"] = ->(args, _ctx) { Types::DynValue.of_bool(compare.call(args[0], args[1]) <= 0) }
+        registry["gt"] = ->(args, _ctx) { Types::DynValue.of_bool(compare.call(args[0], args[1]) > 0) }
+        registry["gte"] = ->(args, _ctx) { Types::DynValue.of_bool(compare.call(args[0], args[1]) >= 0) }
 
         # String operations
         registry["contains"] = ->(args, _ctx) {
@@ -2226,13 +3288,10 @@ module Odin
           end
         }
 
-        # Assertions
+        # Assertions: pass the value through when truthy, else null.
         registry["assert"] = ->(args, _ctx) {
           condition = args[0]
-          msg = args[1]&.to_string || "Assertion failed"
-          raise TransformError.new(msg) unless condition&.truthy?
-
-          Types::DynValue.of_bool(true)
+          condition&.truthy? ? condition : Types::DynValue.of_null
         }
 
         # Switch/cond handled via lazy evaluation in evaluate_verb
@@ -2280,16 +3339,24 @@ module Odin
         }
 
         registry["titleCase"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          Types::DynValue.of_string(s.gsub(/\b\w/) { |m| m.upcase })
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          next Types::DynValue.of_string("") if s.empty?
+          result = s.split(/\s+/).map { |w| w.empty? ? "" : w[0].upcase + w[1..].downcase }.join(" ")
+          Types::DynValue.of_string(result)
         }
 
         registry["slugify"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          next Types::DynValue.of_string("") if s.empty?
           result = s.downcase
-                    .gsub(/[^a-z0-9\s-]/, "")
-                    .strip
-                    .gsub(/[\s-]+/, "-")
+                    .gsub(/[^a-z0-9_\s-]/, "")
+                    .gsub(/[\s_]+/, "-")
+                    .gsub(/-+/, "-")
+                    .gsub(/\A-+|-+\z/, "")
           Types::DynValue.of_string(result)
         }
 
@@ -2366,12 +3433,15 @@ module Odin
         }
 
         registry["split"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          delimiter = args[1]&.to_string || ","
-          parts = s.split(delimiter, -1)
-          # If a third argument (index) is provided, return that element
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          delimiter = args[1]&.to_string || ""
+          parts = delimiter.empty? ? [s] : s.split(delimiter, -1)
+          # If a third argument (index) is provided, return that element.
           if args[2] && !args[2].null?
-            idx = args[2].to_number&.to_i || 0
+            idx = Verbs::NumericVerbs.to_double(args[2])&.to_i || 0
+            idx += parts.length if idx < 0
             if idx >= 0 && idx < parts.length
               Types::DynValue.of_string(parts[idx])
             else
@@ -2402,12 +3472,14 @@ module Odin
         }
 
         registry["match"] = ->(args, _ctx) {
+          next Types::DynValue.of_null if args.length < 2
           s = args[0]&.to_string || ""
           pattern = args[1]&.to_string || ""
           begin
+            next Types::DynValue.of_null if pattern.length > 256 || s.length > 100_000
             Types::DynValue.of_bool(!!(s =~ Regexp.new(pattern)))
           rescue RegexpError
-            Types::DynValue.of_bool(false)
+            Types::DynValue.of_null
           end
         }
         registry["matches"] = registry["match"]
@@ -2451,20 +3523,24 @@ module Odin
         }
 
         registry["repeat"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          count = args[1]&.to_number&.to_i || 0
-          count = 0 if count < 0
-          Types::DynValue.of_string(s * count)
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          count = Verbs::NumericVerbs.to_double(args[1])&.to_i
+          next Types::DynValue.of_null if count.nil? || count < 0
+          count = 100_000 if count > 100_000
+          Types::DynValue.of_string(v.to_string * count)
         }
 
         registry["replaceRegex"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          next Types::DynValue.of_null if args.length < 3 || args[0].nil? || args[0].null?
+          s = args[0].to_string
           pattern = args[1]&.to_string || ""
           replacement = args[2]&.to_string || ""
           begin
+            next Types::DynValue.of_null if pattern.length > 256 || s.length > 100_000
             Types::DynValue.of_string(s.gsub(Regexp.new(pattern), replacement))
           rescue RegexpError
-            Types::DynValue.of_string(s)
+            Types::DynValue.of_null
           end
         }
 
@@ -2477,10 +3553,27 @@ module Odin
         }
 
         registry["wrap"] = ->(args, _ctx) {
+          return Types::DynValue.of_null if args.length < 2
+
           s = args[0]&.to_string || ""
-          prefix = args[1]&.to_string || ""
-          suffix = args[2]&.to_string || ""
-          Types::DynValue.of_string(prefix + s + suffix)
+          width = (args[1]&.to_number || 0).floor
+          return Types::DynValue.of_null if width <= 0
+          return Types::DynValue.of_string(s) if s.length <= width
+
+          lines = []
+          current = +""
+          s.split(/\s+/).each do |word|
+            if current.empty?
+              current = word.dup
+            elsif current.length + 1 + word.length <= width
+              current << " " << word
+            else
+              lines << current
+              current = word.dup
+            end
+          end
+          lines << current unless current.empty?
+          Types::DynValue.of_string(lines.join("\n"))
         }
 
         registry["tokenize"] = ->(args, _ctx) {
@@ -2511,21 +3604,12 @@ module Odin
         }
 
         registry["between"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          start_delim = args[1]&.to_string || ""
-          end_delim = args[2]&.to_string || ""
-          start_idx = s.index(start_delim)
-          if start_idx
-            after_start = start_idx + start_delim.length
-            end_idx = s.index(end_delim, after_start)
-            if end_idx
-              Types::DynValue.of_string(s[after_start...end_idx])
-            else
-              Types::DynValue.of_string("")
-            end
-          else
-            Types::DynValue.of_string("")
-          end
+          return Types::DynValue.of_null if args.length < 3
+
+          value = args[0]&.to_number || 0
+          min = args[1]&.to_number || 0
+          max = args[2]&.to_number || 0
+          Types::DynValue.of_bool(value >= min && value <= max)
         }
 
         # ── Encoding verbs ──
@@ -2537,10 +3621,17 @@ module Odin
         }
 
         registry["base64Decode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string.tr("-_", "+/")
+          pad = (4 - s.length % 4) % 4
+          s += "=" * pad
           require "base64"
           begin
-            Types::DynValue.of_string(Base64.strict_decode64(s))
+            decoded = Base64.strict_decode64(s)
+            decoded.force_encoding("UTF-8")
+            next Types::DynValue.of_null unless decoded.valid_encoding?
+            Types::DynValue.of_string(decoded)
           rescue ArgumentError
             Types::DynValue.of_null
           end
@@ -2552,42 +3643,67 @@ module Odin
         }
 
         registry["hexDecode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
-          begin
-            Types::DynValue.of_string([s].pack("H*"))
-          rescue ArgumentError
-            Types::DynValue.of_null
-          end
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          next Types::DynValue.of_null if s.length.odd? || s.match?(/[^0-9a-fA-F]/)
+          decoded = [s].pack("H*")
+          decoded.force_encoding("UTF-8")
+          next Types::DynValue.of_null unless decoded.valid_encoding?
+          Types::DynValue.of_string(decoded)
         }
 
         registry["urlEncode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
           require "uri"
-          Types::DynValue.of_string(URI.encode_www_form_component(s).gsub("+", "%20"))
+          Types::DynValue.of_string(URI.encode_www_form_component(v.to_string, "UTF-8").gsub("+", "%20").gsub("%7E", "~"))
         }
 
         registry["urlDecode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
+          # Reject malformed percent-encoding (% not followed by two hex digits).
+          next Types::DynValue.of_null if s.scan(/%(..?|.?)/).any? { |seq| seq[0].length != 2 || seq[0].match?(/[^0-9a-fA-F]/) }
           require "uri"
           begin
-            Types::DynValue.of_string(URI.decode_www_form_component(s))
+            decoded = URI.decode_www_form_component(s, "UTF-8")
+            next Types::DynValue.of_null unless decoded.valid_encoding?
+            Types::DynValue.of_string(decoded)
           rescue ArgumentError
-            Types::DynValue.of_string(s)
+            Types::DynValue.of_null
           end
         }
 
         registry["jsonEncode"] = ->(args, _ctx) {
           v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
           require "json"
-          Types::DynValue.of_string(v.nil? || v.null? ? "null" : JSON.generate(v.to_ruby))
+          if v.object? || v.array?
+            next Types::DynValue.of_string(JSON.generate(v.to_ruby))
+          end
+          # Scalars: JSON-escape the string and drop the surrounding quotes.
+          encoded = JSON.generate(v.to_string)
+          Types::DynValue.of_string(encoded[1...-1])
         }
 
         registry["jsonDecode"] = ->(args, _ctx) {
-          s = args[0]&.to_string || ""
+          v = args[0]
+          next Types::DynValue.of_null if v.nil? || v.null?
+          s = v.to_string
           require "json"
+          if s.start_with?("{", "[")
+            begin
+              parsed = JSON.parse(s)
+              next Types::DynValue.from_ruby(parsed) if parsed.is_a?(Hash) || parsed.is_a?(Array)
+            rescue JSON::ParserError
+            end
+          end
+          # Unescape as a JSON string; an invalid escape yields null.
+          next Types::DynValue.of_null unless valid_json_escapes?(s)
           begin
-            parsed = JSON.parse(s)
-            Types::DynValue.from_ruby(parsed)
+            Types::DynValue.of_string(JSON.parse("\"#{s}\""))
           rescue JSON::ParserError
             Types::DynValue.of_null
           end
@@ -2620,7 +3736,7 @@ module Odin
         registry["crc32"] = ->(args, _ctx) {
           s = args[0]&.to_string || ""
           require "zlib"
-          Types::DynValue.of_integer(Zlib.crc32(s))
+          Types::DynValue.of_string(format("%08x", Zlib.crc32(s)))
         }
 
         # ── Logic verbs ──
@@ -2684,13 +3800,38 @@ module Odin
         registry["coerceDate"] = ->(args, _ctx) {
           v = args[0]
           return Types::DynValue.of_null if v.nil? || v.null?
+          return v if v.type == :date
+          if v.type == :timestamp
+            s = v.to_string
+            s = s[0...s.index("T")] if s.include?("T")
+            next Types::DynValue.of_date(s)
+          end
+
           s = v.to_string.strip
-          begin
-            d = Date.parse(s)
-            Types::DynValue.of_date(d.strftime("%Y-%m-%d"))
-          rescue ArgumentError, TypeError
-            Types::DynValue.of_null
+          next Types::DynValue.of_null if s.empty?
+
+          valid_ymd = ->(y, mo, d) { mo.between?(1, 12) && d >= 1 && Date.valid_date?(y, mo, d) }
+
+          # yyyy-MM-dd prefix
+          if s.length >= 10 && s[4] == "-" && s[7] == "-" &&
+             s[0, 4] =~ /\A\d{4}\z/ && s[5, 2] =~ /\A\d{2}\z/ && s[8, 2] =~ /\A\d{2}\z/
+            next Types::DynValue.of_date(s[0, 10])
+          end
+
+          # Compact YYYYMMDD
+          if (m = s.match(/\A(\d{4})(\d{2})(\d{2})\z/))
+            y, mo, d = m[1].to_i, m[2].to_i, m[3].to_i
+            next valid_ymd.call(y, mo, d) ? Types::DynValue.of_date(format("%04d-%02d-%02d", y, mo, d)) : Types::DynValue.of_null
           end
+
+          # Slash MM/DD/YYYY (US), or DD/MM/YYYY when first > 12
+          if (m = s.match(%r{\A(\d{1,2})/(\d{1,2})/(\d{4})\z}))
+            first, second, y = m[1].to_i, m[2].to_i, m[3].to_i
+            mo, d = first > 12 ? [second, first] : [first, second]
+            next valid_ymd.call(y, mo, d) ? Types::DynValue.of_date(format("%04d-%02d-%02d", y, mo, d)) : Types::DynValue.of_null
+          end
+
+          Types::DynValue.of_null
         }
 
         registry["coerceTimestamp"] = ->(args, _ctx) {
@@ -2721,15 +3862,19 @@ module Odin
         registry["toObject"] = ->(args, _ctx) {
           v = args[0]
           if v.nil? || v.null?
-            Types::DynValue.of_object({})
+            Types::DynValue.of_null
           elsif v.object?
             v
           elsif v.array?
+            items = v.value || []
             obj = {}
-            v.value.each_with_index { |item, i| obj[i.to_s] = item }
-            Types::DynValue.of_object(obj)
+            items.each do |item|
+              pair = to_object_pair(item)
+              obj[pair[0]] = pair[1] if pair
+            end
+            obj.empty? ? Types::DynValue.of_null : Types::DynValue.of_object(obj)
           else
-            Types::DynValue.of_object({ "value" => v })
+            Types::DynValue.of_null
           end
         }
 
@@ -2749,7 +3894,7 @@ module Odin
                    end
 
           if seed_arg
-            # Deterministic UUID from seed — matches TypeScript's exact algorithm
+            # Deterministic UUID from seed
             hash1 = 5381
             hash2 = 52711
             seed_arg.each_byte do |c|
@@ -2793,11 +3938,8 @@ module Odin
           digits = raw.gsub(/\D/, "")
           formatted = case country
           when "US", "CA"
-            if digits.length == 10
-              "(#{digits[0..2]}) #{digits[3..5]}-#{digits[6..9]}"
-            elsif digits.length == 11 && digits.start_with?("1")
-              "+1 (#{digits[1..3]}) #{digits[4..6]}-#{digits[7..10]}"
-            end
+            d = (digits.length == 11 && digits.start_with?("1")) ? digits[1..] : digits
+            "(#{d[0..2]}) #{d[3..5]}-#{d[6..9]}" if d.length == 10
           when "GB"
             if digits.length == 11 && digits.start_with?("0")
               "+44 #{digits[1..4]} #{digits[5..10]}"