@@ -1,6 +1,12 @@
 # SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
-"""Pure-MLIR building blocks composed by the ``mlir_string`` lowerings."""
+"""Pure-MLIR building blocks composed by the ``mlir_string`` lowerings.
+
+Helpers work on raw MLIR SSA values (no cuDF/NRT dependency). ``mlir_string``
+layout is ``{ptr meminfo, ptr data, i64 nbytes}``; ops run over an internal
+*view* value ``{ptr data, i32 nbytes, i32 length}`` built by
+:func:`_mlir_string_to_view`.
+"""
 
 from __future__ import annotations
 
@@ -10,6 +16,59 @@
 from numba_cuda_mlir.lowering_utilities import GEP_DYNAMIC_INDEX
 
 
+def _byte_at(data: ir.Value, idx: ir.Value) -> ir.Value:
+    """Load ``data[idx]`` as ``i8`` via a dynamic GEP on the ``i8*`` buffer."""
+    return llvm.load(
+        T.i8(),
+        llvm.getelementptr(
+            llvm.PointerType.get(),
+            data,
+            [idx],
+            [GEP_DYNAMIC_INDEX],
+            T.i8(),
+            None,
+        ),
+    )
+
+
+# --- mlir_string / view field accessors ------------------------------------
+# view layout: {ptr data, i32 nbytes, i32 length}; only data + nbytes are used.
+def _view_data(view_val: ir.Value) -> ir.Value:
+    return llvm.extractvalue(llvm.PointerType.get(), view_val, [0])
+
+
+def _view_nbytes(view_val: ir.Value) -> ir.Value:
+    return llvm.extractvalue(ir.IntegerType.get_signless(32), view_val, [1])
+
+
+def _ms_extract_nbytes(ms_val: ir.Value) -> ir.Value:
+    """Extract ``nbytes`` (i64, field 2) from an ``mlir_string`` value."""
+    return llvm.extractvalue(T.i64(), ms_val, [2])
+
+
+def _mlir_string_to_view(ms_val: ir.Value) -> ir.Value:
+    """Build an internal view ``{ptr data, i32 nbytes, i32 length}``.
+
+    ``length`` is set equal to ``nbytes`` here; the character count is computed
+    on demand by :func:`_lower_len`.
+    """
+    i32 = ir.IntegerType.get_signless(32)
+    ptr = llvm.PointerType.get()
+    data = llvm.extractvalue(ptr, ms_val, [1])
+    nbytes_i32 = arith.trunci(i32, _ms_extract_nbytes(ms_val))
+    view_ty = llvm.StructType.get_literal([ptr, i32, i32])
+    val = llvm.UndefOp(view_ty)
+    val = llvm.insertvalue(
+        container=val, value=data, position=ir.DenseI64ArrayAttr.get([0])
+    )
+    val = llvm.insertvalue(
+        container=val, value=nbytes_i32, position=ir.DenseI64ArrayAttr.get([1])
+    )
+    return llvm.insertvalue(
+        container=val, value=nbytes_i32, position=ir.DenseI64ArrayAttr.get([2])
+    )
+
+
 def _is_begin_utf8_char(byte_val: ir.Value) -> ir.Value:
     """i1: whether ``byte_val`` is a UTF-8 start byte (top 2 bits != ``10``)."""
     i32 = ir.IntegerType.get_signless(32)
@@ -19,35 +78,28 @@ def _is_begin_utf8_char(byte_val: ir.Value) -> ir.Value:
     )
 
 
-def _lower_len(ms_val: ir.Value) -> ir.Value:
-    """``len(mlir_string) -> i64`` character count (pure MLIR).
+def _lower_len(str_view: ir.Value) -> ir.Value:
+    """``len`` -> ``i32`` character count (number of UTF-8 start bytes).
 
-    Counts UTF-8 start bytes over the ``nbytes``-long data buffer, so the result
-    is the number of characters (code points), matching cuDF ``str.len``. The
-    count is accumulated directly in ``i64`` to match the declared result type.
-    The ``mlir_string`` layout is ``{ptr meminfo, ptr data, i64 nbytes}`` --
-    fields 1 (``data``) and 2 (``nbytes``) are read below.
+    ``int32`` matches libcudf's ``size_type`` used for string lengths.
     """
-    data = llvm.extractvalue(llvm.PointerType.get(), ms_val, [1])
-    nb = llvm.extractvalue(T.i64(), ms_val, [2])
-    zero_i64 = arith.constant(T.i64(), 0)
-    one_i64 = arith.constant(T.i64(), 1)
-
-    loop = scf.ForOp(zero_i64, nb, one_i64, [zero_i64])
+    i32 = ir.IntegerType.get_signless(32)
+    data = _view_data(str_view)
+    nb = llvm.zext(T.i64(), _view_nbytes(str_view))
+    zero_i32 = arith.constant(i32, 0)
+    loop = scf.ForOp(
+        arith.constant(T.i64(), 0),
+        nb,
+        arith.constant(T.i64(), 1),
+        [zero_i32],
+    )
     with ir.InsertionPoint(loop.body):
         idx = loop.induction_variable
         acc = loop.inner_iter_args[0]
-        # data[idx] -- GEP a dynamic byte offset into the i8* buffer
-        byte_ptr = llvm.getelementptr(
-            llvm.PointerType.get(),
-            data,
-            [idx],
-            [GEP_DYNAMIC_INDEX],
-            T.i8(),
-            None,
+        inc = arith.select(
+            _is_begin_utf8_char(_byte_at(data, idx)),
+            arith.constant(i32, 1),
+            zero_i32,
         )
-        b = llvm.load(T.i8(), byte_ptr)
-        inc = arith.select(_is_begin_utf8_char(b), one_i64, zero_i64)
         scf.yield_([arith.addi(acc, inc)])
-
     return loop.results[0]
@@ -34,13 +34,16 @@
     from numba_cuda_mlir.mlir_lowering import MLIRLower
     from numba_cuda_mlir.numba_cuda.core.ir import Var
 
+# libcudf size_type; the width of a string length result.
+size_type = types.int32
+
 
 class LenMLIRStringTemplate(AbstractTemplate):
     """``len`` over strings.
 
-    ``len(mlir_string)`` -> ``int64`` (UTF-8 character count), and
-    ``len(Masked(mlir_string))`` -> ``Masked(int64)`` (validity carried from the
-    operand).
+    ``len(mlir_string)`` -> ``int32`` (UTF-8 character count), and
+    ``len(Masked(mlir_string))`` -> ``Masked(int32)`` (validity carried from the
+    operand). ``int32`` matches libcudf's ``size_type`` for string lengths.
     """
 
     key = len
@@ -60,34 +63,34 @@ def generic(
         Returns
         -------
         Signature or None
-            ``int64`` for a bare ``mlir_string``, ``Masked(int64)`` for a
+            ``int32`` for a bare ``mlir_string``, ``Masked(int32)`` for a
             ``Masked(mlir_string)``, else ``None``.
         """
         if len(args) != 1 or kws:
             return None
         arg = args[0]
         if isinstance(arg, MLIRStringType):
-            return nb_signature(types.int64, mlir_string)
+            return nb_signature(size_type, mlir_string)
         if isinstance(arg, MaskedType) and isinstance(
             arg.value_type, MLIRStringType
         ):
-            return nb_signature(MaskedType(types.int64), arg)
+            return nb_signature(MaskedType(size_type), arg)
         return None
 
 
 def _lower_len(
     builder: MLIRLower, target: Var, args: list[Var], kwargs: list
 ) -> None:
-    """``len(mlir_string)``: count UTF-8 characters, returned as ``int64``."""
-    ms_val = builder.load_var(args[0])
-    builder.store_var(target, _impl._lower_len(ms_val))
+    """``len(mlir_string)``: count UTF-8 characters, returned as ``int32``."""
+    view = _impl._mlir_string_to_view(builder.load_var(args[0]))
+    builder.store_var(target, _impl._lower_len(view))
 
 
 def _lower_masked_len(
     builder: MLIRLower, target: Var, args: list[Var], kwargs: list
 ) -> None:
     """``len(Masked(mlir_string))``: character count packed with the operand's
-    validity bit (``Masked(int64)``).
+    validity bit (``Masked(int32)``).
 
     The payload is scanned unconditionally; this is safe because null rows carry
     ``nbytes == 0`` (the marshaller leaves a null ``data`` pointer with zero
@@ -97,9 +100,9 @@ def _lower_masked_len(
     m = builder.load_var(args[0])
     st = llvm.StructType(m.type)
     ms_val, m_valid = _extract_masked_value_valid(m, st.body[0], st.body[1])
-    count_i64 = _impl._lower_len(ms_val)
+    count = _impl._lower_len(_impl._mlir_string_to_view(ms_val))
     target_type = builder.get_numba_type(target.name)
-    packed = _pack_masked(builder, target_type, count_i64, m_valid)
+    packed = _pack_masked(builder, target_type, count, m_valid)
     builder.store_var(target, packed)