diff --git a/src/context.zig b/src/context.zig
index f723366..8b5dd92 100644
--- a/src/context.zig
+++ b/src/context.zig
@@ -40,7 +40,7 @@ pub const Context = struct {
             .bool => Value{ .bool = value },
             .int, .comptime_int => Value{ .int = @intCast(value) },
             .float, .comptime_float => Value{ .float = @floatCast(value) },
-            .pointer => Value{ .string = std.fmt.allocPrint(self.allocator(), "{s}", .{value}) catch "" },
+            .pointer => Value{ .string = try std.fmt.allocPrint(self.allocator(), "{s}", .{value}) },
             .@"struct" => blk: {
                 var dict = std.StringHashMapUnmanaged(Value){};
                 inline for (std.meta.fields(T)) |field| {
@@ -59,13 +59,14 @@ pub const Context = struct {
             },
             .optional => if (value) |v| try self.toValue(v) else .null,
             .null => .null,
+            // CASO ESPECIAL: o valor já é um Value (ex: lista de Value)
+            .@"union" => if (T == Value) value else @compileError("Unsupported union type: " ++ @typeName(T)),
             else => @compileError("Unsupported type: " ++ @typeName(T)),
         };
     }
 
     pub fn set(self: *Context, key: []const u8, value: anytype) !void {
         const v = try self.toValue(value);
-
         const gop = try self.map.getOrPut(self.allocator(), key);
         if (!gop.found_existing) {
             gop.key_ptr.* = try self.allocator().dupe(u8, key);
diff --git a/src/context_test.zig b/src/context_test.zig
index d3702b6..899284a 100644
--- a/src/context_test.zig
+++ b/src/context_test.zig
@@ -18,8 +18,8 @@ test "context set amigável e get com ponto" {
     const Person = struct { nome: []const u8, idade: i64 };
     const p = Person{ .nome = "Ana", .idade = 25 };
     try ctx.set("user", p);
-    //
-    // // list
+
+    // list
     const numeros = [_]i64{ 1, 2, 3 };
     try ctx.set("lista", numeros);
 
diff --git a/src/filters.zig b/src/filters.zig
new file mode 100644
index 0000000..b86d356
--- /dev/null
+++ b/src/filters.zig
@@ -0,0 +1,1517 @@
+const std = @import("std");
+const Value = @import("context.zig").Value;
+const std_time = std.time;
+
+pub const FilterError = error{
+    InvalidArgument,
+    OutOfMemory,
+};
+
+const DictEntry = struct {
+    key: []const u8,
+    val: Value,
+};
+
+pub const FilterFn = fn (alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value;
+
+// ==================== FILTROS BUILTIN ====================
+fn filter_add(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    const addend = arg orelse return value;
+
+    return switch (value) {
+        .int => |i| switch (addend) {
+            .int => |a| Value{ .int = i + a },
+            .float => |a| Value{ .float = @as(f64, @floatFromInt(i)) + a },
+            else => value,
+        },
+        .float => |f| switch (addend) {
+            .int => |a| Value{ .float = f + @as(f64, @floatFromInt(a)) },
+            .float => |a| Value{ .float = f + a },
+            else => value,
+        },
+        else => value,
+    };
+}
+
+fn filter_addslashes(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    for (s) |c| {
+        switch (c) {
+            '\'', '"', '\\' => {
+                try result.append(alloc, '\\');
+                try result.append(alloc, c);
+            },
+            else => try result.append(alloc, c),
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_capfirst(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    if (s.len == 0) return value;
+
+    const capped = capFirst(alloc, s) catch s;
+    return Value{ .string = capped };
+}
+
+fn filter_center(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    const width = switch (arg orelse Value{ .int = 80 }) {
+        .int => |i| @as(usize, @max(@as(i64, i), 0)),
+        else => 80,
+    };
+
+    if (s.len >= width) return value;
+
+    const padding = width - s.len;
+    const left = padding / 2;
+    const right = padding - left;
+
+    var result = std.ArrayList(u8){};
+
+    for (0..left) |_| try result.append(alloc, ' ');
+    try result.appendSlice(alloc, s);
+    for (0..right) |_| try result.append(alloc, ' ');
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_cut(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    const to_cut = switch (arg orelse return value) {
+        .string => |cut| cut,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    var i: usize = 0;
+    while (i < s.len) {
+        if (i + to_cut.len <= s.len and std.mem.eql(u8, s[i .. i + to_cut.len], to_cut)) {
+            i += to_cut.len;
+        } else {
+            try result.append(alloc, s[i]);
+            i += 1;
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+// fn filter_date(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+//     // Por enquanto, simples: aceita string ou int (timestamp) e formata com strftime-like
+//     // Futuro: suporte completo a std.time
+//     _ = alloc;
+//     const format = switch (arg orelse Value{ .string = "d/m/Y" }) {
+//         .string => |f| f,
+//         else => "d/m/Y",
+//     };
+//
+//     const timestamp = switch (value) {
+//         .int => |i| @as(i64, i),
+//         .string => |s| std.fmt.parseInt(i64, s, 10) catch 0,
+//         else => 0,
+//     };
+//
+//     // Simulação simples (em produção usar std.time)
+//     const day = @rem(timestamp, 30) + 1;
+//     const month = @rem(timestamp / 30, 12) + 1;
+//     const year = 2026 + @divFloor(timestamp, 360);
+//
+//     var buf: [64]u8 = undefined;
+//     const formatted = switch (format) {
+//         "d/m/Y" => std.fmt.bufPrint(&buf, "{d:0>2}/{d:0>2}/{d}", .{ day, month, year }) catch "??/??/????",
+//         "Y-m-d" => std.fmt.bufPrint(&buf, "{d}-{d:0>2}-{d:0>2}", .{ year, month, day }) catch "????-??-??",
+//         else => "formato não suportado",
+//     };
+//
+//     return Value{ .string = try alloc.dupe(u8, formatted) };
+// }
+
+fn filter_default(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    const def = arg orelse return value;
+
+    return switch (value) {
+        .null => def,
+        .string => |s| if (s.len == 0) def else value,
+        .list => |l| if (l.len == 0) def else value,
+        else => value,
+    };
+}
+
+fn filter_default_if_none(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    const def = arg orelse return value;
+    return if (value == .null) def else value;
+}
+
+fn filter_dictsort(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const d = switch (value) {
+        .dict => |dict| dict,
+        else => return value,
+    };
+
+    var entries = std.ArrayList(Value){};
+
+    var keys = std.ArrayList([]const u8){};
+    defer keys.deinit(alloc);
+
+    var iter = d.iterator();
+    while (iter.next()) |entry| {
+        const key_copy = try alloc.dupe(u8, entry.key_ptr.*);
+        try keys.append(alloc, key_copy);
+    }
+
+    std.mem.sort([]const u8, keys.items, {}, struct {
+        pub fn lessThan(ctx: void, a: []const u8, b: []const u8) bool {
+            _ = ctx;
+            return std.mem.order(u8, a, b) == .lt;
+        }
+    }.lessThan);
+
+    for (keys.items) |key| {
+        const val = d.get(key).?;
+        const pair = std.StringHashMapUnmanaged(Value){};
+        var pair_map = pair;
+        try pair_map.put(alloc, "key", Value{ .string = key });
+        try pair_map.put(alloc, "value", val);
+        try entries.append(alloc, Value{ .dict = pair_map });
+    }
+
+    return Value{ .list = try entries.toOwnedSlice(alloc) };
+}
+
+fn filter_dictsortreversed(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const sorted = try filter_dictsort(alloc, value, arg);
+
+    const list = sorted.list;
+    const reversed = try alloc.dupe(Value, list);
+    std.mem.reverse(Value, reversed);
+
+    return Value{ .list = reversed };
+}
+
+fn filter_divisibleby(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    const divisor = switch (arg orelse return Value{ .bool = false }) {
+        .int => |i| if (i == 0) return Value{ .bool = false } else i,
+        else => return Value{ .bool = false },
+    };
+
+    const n = switch (value) {
+        .int => |i| i,
+        .float => |f| @as(i64, @intFromFloat(f)),
+        else => return Value{ .bool = false },
+    };
+
+    return Value{ .bool = @rem(n, divisor) == 0 };
+}
+
+fn filter_escape(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    return filter_force_escape(alloc, value, arg); // alias de force_escape
+}
+
+fn filter_escapejs(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    for (s) |c| {
+        switch (c) {
+            '\'', '"', '\\' => {
+                try result.append(alloc, '\\');
+                try result.append(alloc, c);
+            },
+            '\n' => try result.appendSlice(alloc, "\\n"),
+            '\r' => try result.appendSlice(alloc, "\\r"),
+            '\t' => try result.appendSlice(alloc, "\\t"),
+            '<' => try result.appendSlice(alloc, "\\<"),
+            '>' => try result.appendSlice(alloc, "\\>"),
+            '&' => try result.appendSlice(alloc, "\\&"),
+            '=' => try result.appendSlice(alloc, "\\="),
+            '-' => try result.appendSlice(alloc, "\\-"),
+            ';' => try result.appendSlice(alloc, "\\-"),
+            // Agora sem overlap: excluímos \n (0x0A), \r (0x0D), \t (0x09)
+            0x00...0x08, 0x0B...0x0C, 0x0E...0x1F, 0x7F => {
+                try std.fmt.format(result.writer(alloc), "\\u{:0>4}", .{c});
+            },
+            else => try result.append(alloc, c),
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_escapeseq(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    for (s) |c| {
+        switch (c) {
+            '\\' => try result.appendSlice(alloc, "\\\\"),
+            '\n' => try result.appendSlice(alloc, "\\n"),
+            '\r' => try result.appendSlice(alloc, "\\r"),
+            '\t' => try result.appendSlice(alloc, "\\t"),
+            '"' => try result.appendSlice(alloc, "\\\""),
+            '\'' => try result.appendSlice(alloc, "\\'"),
+            else => try result.append(alloc, c),
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_filesizeformat(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const bytes = switch (value) {
+        .int => |i| @as(f64, @floatFromInt(i)),
+        .float => |f| f,
+        else => return value,
+    };
+
+    const units = [_][]const u8{ "B", "KB", "MB", "GB", "TB" };
+    var size = bytes;
+    var unit_index: usize = 0;
+
+    while (size >= 1024 and unit_index < units.len - 1) {
+        size /= 1024;
+        unit_index += 1;
+    }
+
+    const formatted = if (size < 10)
+        try std.fmt.allocPrint(alloc, "{d:.1} {s}", .{ size, units[unit_index] })
+    else
+        try std.fmt.allocPrint(alloc, "{d:.0} {s}", .{ size, units[unit_index] });
+
+    return Value{ .string = formatted };
+}
+
+fn filter_first(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    _ = arg;
+    return switch (value) {
+        .list => |l| if (l.len > 0) l[0] else .null,
+        .string => |s| if (s.len > 0) Value{ .string = s[0..1] } else .null,
+        else => .null,
+    };
+}
+
+fn filter_floatformat(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const f = switch (value) {
+        .float => |f| f,
+        .int => |i| @as(f64, @floatFromInt(i)),
+        else => return value,
+    };
+
+    const precision = switch (arg orelse Value{ .int = -1 }) {
+        .int => |i| if (i < 0) null else @as(usize, @intCast(i)),
+        else => null,
+    };
+
+    var buf: [64]u8 = undefined;
+    const formatted = if (precision) |p| blk: {
+        // Usamos switch para evitar placeholder dinâmico
+        const str = switch (p) {
+            0 => std.fmt.bufPrint(&buf, "{d:.0}", .{f}) catch unreachable,
+            1 => std.fmt.bufPrint(&buf, "{d:.1}", .{f}) catch unreachable,
+            2 => std.fmt.bufPrint(&buf, "{d:.2}", .{f}) catch unreachable,
+            3 => std.fmt.bufPrint(&buf, "{d:.3}", .{f}) catch unreachable,
+            4 => std.fmt.bufPrint(&buf, "{d:.4}", .{f}) catch unreachable,
+            5 => std.fmt.bufPrint(&buf, "{d:.5}", .{f}) catch unreachable,
+            else => std.fmt.bufPrint(&buf, "{d}", .{f}) catch unreachable,
+        };
+        break :blk try alloc.dupe(u8, str);
+    } else try std.fmt.allocPrint(alloc, "{d}", .{f});
+
+    return Value{ .string = formatted };
+}
+
+fn filter_force_escape(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+    defer result.deinit(alloc);
+
+    for (s) |c| {
+        switch (c) {
+            '&' => try result.appendSlice(alloc, "&amp;"),
+            '<' => try result.appendSlice(alloc, "&lt;"),
+            '>' => try result.appendSlice(alloc, "&gt;"),
+            '"' => try result.appendSlice(alloc, "&quot;"),
+            '\'' => try result.appendSlice(alloc, "&#x27;"),
+            else => try result.append(alloc, c),
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_get_digit(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const n = switch (value) {
+        .int => |i| i,
+        else => return value,
+    };
+
+    const pos = switch (arg orelse Value{ .int = 1 }) {
+        .int => |p| p,
+        else => 1,
+    };
+
+    if (pos <= 0) return Value{ .int = 0 };
+
+    const abs = if (n < 0) -1 * n else n;
+    const str = try std.fmt.allocPrint(alloc, "{d}", .{abs});
+
+    if (pos > str.len) return Value{ .int = 0 };
+
+    const pos_usize = @as(usize, @intCast(pos));
+    const npos = str.len - (pos_usize - 1);
+
+    if (pos <= str.len) return Value{ .int = @intCast(npos) };
+
+    return Value{ .int = 0 };
+}
+
+fn filter_iriencode(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    for (s) |c| {
+        if (std.ascii.isAlphanumeric(c) or c == '-' or c == '.' or c == '_' or c == '~') {
+            try result.append(alloc, c);
+        } else {
+            try std.fmt.format(result.writer(alloc), "%{X:0>2}", .{c});
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+fn filter_join(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const sep = switch (arg orelse Value{ .string = "," }) {
+        .string => |s| s,
+        else => ",",
+    };
+
+    const list = switch (value) {
+        .list => |l| l,
+        else => return value,
+    };
+
+    if (list.len == 0) return Value{ .string = "" };
+
+    var result = std.ArrayList(u8){};
+    defer result.deinit(alloc);
+
+    for (list, 0..) |item, i| {
+        if (i > 0) try result.appendSlice(alloc, sep);
+
+        // const str = switch (item) {
+        //     .string => |s| s,
+        //     .int => |n| blk: {
+        //         const printed = try std.fmt.allocPrint(alloc, "{d}", .{n});
+        //         break :blk printed;
+        //     },
+        //     .float => |f| blk: {
+        //         const printed = try std.fmt.allocPrint(alloc, "{d}", .{f});
+        //         break :blk printed;
+        //     },
+        //     .bool => |b| if (b) "true" else "false",
+        //     .null => "None",
+        //     .list, .dict => blk: {
+        //         const printed = try std.fmt.allocPrint(alloc, "{}", .{item});
+        //         break :blk printed;
+        //     },
+        // };
+        const str = try valueToSafeString(alloc, item);
+        try result.appendSlice(alloc, str);
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+// TODO: refactor
+fn filter_json_script(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    // Simples: converte para string JSON-like e escapa para uso em <script>
+    const str = switch (value) {
+        .string => |s| s,
+        else => try std.fmt.allocPrint(alloc, "{}", .{value}),
+    };
+    errdefer if (@typeInfo(@TypeOf(str)) == .pointer) alloc.free(str);
+
+    var result = std.ArrayList(u8){};
+
+    for (str) |c| {
+        switch (c) {
+            '<' => try result.appendSlice(alloc, "\\u003C"),
+            '>' => try result.appendSlice(alloc, "\\u003E"),
+            '&' => try result.appendSlice(alloc, "\\u0026"),
+            else => try result.append(alloc, c),
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_last(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    _ = arg;
+    return switch (value) {
+        .list => |l| if (l.len > 0) l[l.len - 1] else .null,
+        .string => |s| if (s.len > 0) Value{ .string = s[s.len - 1 ..] } else .null,
+        else => .null,
+    };
+}
+
+fn filter_length(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    _ = arg;
+    return Value{ .int = switch (value) {
+        .string => |s| @intCast(s.len),
+        .list => |l| @intCast(l.len),
+        .dict => |d| @intCast(d.count()),
+        else => 0,
+    } };
+}
+
+fn filter_linebreaks(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+    defer result.deinit(alloc);
+
+    var lines = std.mem.splitScalar(u8, s, '\n');
+    var empty_line_count: usize = 0;
+
+    while (lines.next()) |line| {
+        const trimmed = std.mem.trim(u8, line, " \t\r");
+
+        if (trimmed.len == 0) {
+            empty_line_count += 1;
+            if (empty_line_count == 1) {
+                try result.appendSlice(alloc, "<p>");
+            } else if (empty_line_count == 2) {
+                try result.appendSlice(alloc, "</p><p>");
+                empty_line_count = 1;
+            }
+        } else {
+            if (empty_line_count >= 1) {
+                try result.appendSlice(alloc, "<p>");
+                empty_line_count = 0;
+            }
+            try result.appendSlice(alloc, line);
+            try result.appendSlice(alloc, "<br>");
+        }
+    }
+
+    if (empty_line_count >= 1) try result.appendSlice(alloc, "</p>");
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_linebreaksbr(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+    defer result.deinit(alloc);
+
+    for (s) |c| {
+        if (c == '\n') {
+            try result.appendSlice(alloc, "<br>");
+        } else {
+            try result.append(alloc, c);
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_linenumbers(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    var lines = std.mem.splitScalar(u8, s, '\n');
+    var line_num: usize = 1;
+
+    while (lines.next()) |line| {
+        try std.fmt.format(result.writer(alloc), "{d}. ", .{line_num});
+        try result.appendSlice(alloc, line);
+        try result.append(alloc, '\n');
+        line_num += 1;
+    }
+
+    // Remove última \n se existir
+    if (result.items.len > 0 and result.items[result.items.len - 1] == '\n') {
+        _ = result.pop();
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_ljust(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    const width = if (arg) |a| switch (a) {
+        .int => |i| @as(usize, @max(i, 0)),
+        else => s.len,
+    } else s.len;
+
+    if (s.len >= width) return value;
+
+    var result = std.ArrayList(u8){};
+    try result.appendSlice(alloc, s);
+    for (s.len..width) |_| try result.append(alloc, ' ');
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_lower(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    const lowered = toLower(alloc, s) catch s;
+    return Value{ .string = lowered };
+}
+
+fn filter_make_list(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var list = std.ArrayList(Value){};
+
+    for (s) |c| {
+        var char_str: [4]u8 = undefined;
+        const len = std.unicode.utf8Encode(c, &char_str) catch 1;
+        const char_slice = char_str[0..len];
+        const copied = try alloc.dupe(u8, char_slice);
+        try list.append(alloc, Value{ .string = copied });
+    }
+
+    return Value{ .list = try list.toOwnedSlice(alloc) };
+}
+
+fn filter_phone2numeric(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    for (s) |c| {
+        const lower = std.ascii.toLower(c);
+        const digit = switch (lower) {
+            'a', 'b', 'c' => '2',
+            'd', 'e', 'f' => '3',
+            'g', 'h', 'i' => '4',
+            'j', 'k', 'l' => '5',
+            'm', 'n', 'o' => '6',
+            'p', 'q', 'r', 's' => '7',
+            't', 'u', 'v' => '8',
+            'w', 'x', 'y', 'z' => '9',
+            else => c,
+        };
+        try result.append(alloc, digit);
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+//
+// TODO: refactor
+fn filter_pluralize(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    var singular: []const u8 = "";
+    var plural: []const u8 = "s";
+
+    if (arg) |a| {
+        switch (a) {
+            .string => |str| {
+                if (std.mem.indexOf(u8, str, ",")) |pos| {
+                    singular = str[0..pos];
+                    plural = str[pos + 1 ..];
+                } else {
+                    plural = str;
+                }
+            },
+            else => {}, // ignora outros tipos
+        }
+    }
+
+    const count: i64 = switch (value) {
+        .int => |i| i,
+        .float => |f| @as(i64, @intFromFloat(f)),
+        .string => |s| if (s.len == 0) 0 else 1,
+        .list => |l| @as(i64, @intCast(l.len)),
+        .dict => |d| @as(i64, @intCast(d.count())),
+        .null => 0,
+        else => 1,
+    };
+
+    const ending = if (count == 1 or count == -1) singular else plural;
+
+    const copied = try alloc.dupe(u8, ending);
+    return Value{ .string = copied };
+}
+
+fn filter_pprint(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const str = try valueToSafeString(alloc, value);
+    return Value{ .string = str };
+}
+
+fn filter_random(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    _ = arg;
+    const list = switch (value) {
+        .list => |l| l,
+        else => return value,
+    };
+
+    if (list.len == 0) return Value.null;
+
+    var prng = std.Random.DefaultPrng.init(@intCast(std.time.milliTimestamp()));
+    const rand = prng.random();
+
+    const index = rand.uintLessThan(usize, list.len);
+    return list[index];
+}
+
+fn filter_rjust(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    const width = if (arg) |a| switch (a) {
+        .int => |i| @as(usize, @max(i, 0)),
+        else => s.len,
+    } else s.len;
+
+    if (s.len >= width) return value;
+
+    var result = std.ArrayList(u8){};
+    for (s.len..width) |_| try result.append(alloc, ' ');
+    try result.appendSlice(alloc, s);
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_safe(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    _ = arg;
+    return value; // safe: o renderer não escapa
+}
+
+fn filter_safeseq(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    _ = arg;
+    const list = switch (value) {
+        .list => |l| l,
+        else => return value,
+    };
+
+    // safeseq marca a lista como segura (não escapa itens)
+    // Por enquanto, retorna a mesma lista (o renderer vai tratar como safe)
+    return Value{ .list = list };
+}
+
+fn filter_slice(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const slice_str = switch (arg orelse return value) {
+        .string => |s| s,
+        else => return value,
+    };
+
+    var start: ?usize = null;
+    var end: ?usize = null;
+
+    if (std.mem.indexOf(u8, slice_str, ":")) |colon| {
+        const before = slice_str[0..colon];
+        const after = slice_str[colon + 1 ..];
+
+        if (before.len > 0) {
+            start = std.fmt.parseInt(usize, before, 10) catch 0;
+        }
+        if (after.len > 0) {
+            end = std.fmt.parseInt(usize, after, 10) catch null;
+        }
+    } else {
+        return value;
+    }
+
+    return switch (value) {
+        .string => |s| blk: {
+            const effective_start = start orelse 0;
+            const effective_end = end orelse s.len;
+            if (effective_start >= s.len) return Value{ .string = "" };
+            const len = @min(effective_end - effective_start, s.len - effective_start);
+            const sliced = try alloc.dupe(u8, s[effective_start .. effective_start + len]);
+            break :blk Value{ .string = sliced };
+        },
+        .list => |l| blk: {
+            const effective_start = start orelse 0;
+            const effective_end = end orelse l.len;
+            if (effective_start >= l.len) return Value{ .list = &.{} };
+            const len = @min(effective_end - effective_start, l.len - effective_start);
+            const sliced = try alloc.dupe(Value, l[effective_start .. effective_start + len]);
+            break :blk Value{ .list = sliced };
+        },
+        else => value,
+    };
+}
+
+fn filter_slugify(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    var last_was_hyphen = false;
+    var i: usize = 0;
+
+    while (i < s.len) {
+        var replaced: u8 = s[i];
+
+        // Se for caractere acentuado de 2 bytes (UTF-8 Latin-1: 0xC3 xx)
+        if (i + 1 < s.len and s[i] == 0xC3) {
+            const next = s[i + 1];
+            replaced = switch (next) {
+                // Minúsculos
+                0xA1, 0xA0, 0xA2, 0xA3, 0xA4 => 'a', // á à â ã ä
+                0xA9, 0xA8, 0xAA, 0xAB => 'e', // é è ê ë
+                0xAD, 0xAC, 0xAE, 0xAF => 'i', // í ì î ï
+                0xB3, 0xB2, 0xB4, 0xB5, 0xB6 => 'o', // ó ò ô õ ö
+                0xBA, 0xB9, 0xBB, 0xBC => 'u', // ú ù û ü
+                0xA7 => 'c', // ç
+                0xB1 => 'n', // ñ
+
+                // Maiúsculos (convertidos para minúsculo)
+                0x81, 0x80, 0x82, 0x83, 0x84 => 'a', // Á À Â Ã Ä
+                0x89, 0x88, 0x8A, 0x8B => 'e', // É È Ê Ë
+                0x8D, 0x8C, 0x8E, 0x8F => 'i', // Í Ì Î Ï
+                0x93, 0x92, 0x94, 0x95, 0x96 => 'o', // Ó Ò Ô Õ Ö
+                0x9A, 0x99, 0x9B, 0x9C => 'u', // Ú Ù Û Ü
+                0x87 => 'c', // Ç
+                0x91 => 'n', // Ñ
+                else => std.ascii.toLower(s[i]),
+            };
+            i += 2;
+        } else {
+            replaced = std.ascii.toLower(s[i]);
+            i += 1;
+        }
+
+        if (std.ascii.isAlphanumeric(replaced)) {
+            try result.append(alloc, replaced);
+            last_was_hyphen = false;
+        } else if (replaced == ' ' or replaced == '-' or replaced == '_') {
+            if (!last_was_hyphen and result.items.len > 0) {
+                try result.append(alloc, '-');
+            }
+            last_was_hyphen = true;
+        } else {
+            last_was_hyphen = false;
+        }
+    }
+
+    // Remove hífen final
+    if (result.items.len > 0 and result.items[result.items.len - 1] == '-') {
+        _ = result.pop();
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_stringformat(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const format_str = switch (arg orelse return value) {
+        .string => |s| s,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    var i: usize = 0;
+    while (i < format_str.len) {
+        if (format_str[i] == '%' and i + 1 < format_str.len) {
+            i += 1;
+            const specifier = format_str[i];
+            const str = switch (specifier) {
+                's' => switch (value) {
+                    .string => |s| s,
+                    else => try std.fmt.allocPrint(alloc, "{}", .{value}),
+                },
+                'd' => switch (value) {
+                    .int => |n| try std.fmt.allocPrint(alloc, "{d}", .{n}),
+                    else => try std.fmt.allocPrint(alloc, "{}", .{value}),
+                },
+                'f' => switch (value) {
+                    .float => |f| try std.fmt.allocPrint(alloc, "{d}", .{f}),
+                    .int => |n| try std.fmt.allocPrint(alloc, "{d}", .{@as(f64, @floatFromInt(n))}),
+                    else => try std.fmt.allocPrint(alloc, "{}", .{value}),
+                },
+                '%' => "%",
+                else => blk: {
+                    try result.append(alloc, '%');
+                    try result.append(alloc, specifier);
+                    break :blk "";
+                },
+            };
+            try result.appendSlice(alloc, str);
+            if (@typeInfo(@TypeOf(str)) == .pointer) alloc.free(str);
+        } else {
+            try result.append(alloc, format_str[i]);
+        }
+        i += 1;
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_striptags(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    var in_tag = false;
+    for (s) |c| {
+        if (c == '<') {
+            in_tag = true;
+        } else if (c == '>' and in_tag) {
+            in_tag = false;
+        } else if (!in_tag) {
+            try result.append(alloc, c);
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_timesince(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const then = switch (value) {
+        .int => |i| @as(i64, i),
+        else => std_time.timestamp(),
+    };
+
+    const now = std_time.timestamp();
+    var diff = now - then;
+    if (diff < 0) diff = -diff;
+
+    if (diff < 60) {
+        return Value{ .string = try alloc.dupe(u8, "menos de um minuto") };
+    } else if (diff < 3600) {
+        const mins = diff / 60;
+        const str = if (mins == 1) "1 minuto" else try std.fmt.allocPrint(alloc, "{d} minutos", .{mins});
+        return Value{ .string = str };
+    } else if (diff < 86400) {
+        const hours = diff / 3600;
+        const str = if (hours == 1) "1 hora" else try std.fmt.allocPrint(alloc, "{d} horas", .{hours});
+        return Value{ .string = str };
+    } else {
+        const days = diff / 86400;
+        const str = if (days == 1) "1 dia" else try std.fmt.allocPrint(alloc, "{d} dias", .{days});
+        return Value{ .string = str };
+    }
+}
+
+fn filter_timeuntil(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    // Reutiliza timesince, mas com sinal invertido
+    const future = switch (value) {
+        .int => |i| @as(i64, i),
+        else => std_time.timestamp(),
+    };
+
+    const fake_past = Value{ .int = std_time.timestamp() };
+    const since = try filter_timesince(alloc, fake_past, Value{ .int = future });
+    return since;
+}
+
+fn filter_title(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    var word_start = true;
+    for (s) |c| {
+        if (std.ascii.isAlphanumeric(c)) {
+            try result.append(alloc, if (word_start) std.ascii.toUpper(c) else std.ascii.toLower(c));
+            word_start = false;
+        } else {
+            try result.append(alloc, c);
+            word_start = true;
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_truncatechars(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    const n = switch (arg orelse Value{ .int = 100 }) {
+        .int => |i| @as(usize, @max(i, 0)),
+        else => 100,
+    };
+    const ellipsis_len = 3;
+
+    if (n <= ellipsis_len) return Value{ .string = "" };
+    if (s.len <= n) return value;
+
+    const truncate_to = n - ellipsis_len;
+    const truncated = try alloc.alloc(u8, n);
+    @memcpy(truncated[0..truncate_to], s[0..truncate_to]);
+    @memcpy(truncated[truncate_to..], "...");
+    return Value{ .string = truncated };
+}
+
+fn filter_truncatechars_html(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    // Similar, mas poderia verificar tags HTML abertas — implementação avançada depois
+    return filter_truncatechars(alloc, value, arg);
+}
+
+fn filter_truncatewords(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    const n = switch (arg orelse Value{ .int = 20 }) {
+        .int => |i| @as(usize, @max(i, 0)),
+        else => 20,
+    };
+
+    if (n == 0) return Value{ .string = "..." };
+
+    var words = std.mem.splitScalar(u8, s, ' ');
+    var result = std.ArrayList(u8){};
+    defer result.deinit(alloc);
+
+    var count: usize = 0;
+    while (words.next()) |word| : (count += 1) {
+        if (count == n) {
+            try result.appendSlice(alloc, "...");
+            break;
+        }
+        if (count > 0) try result.append(alloc, ' ');
+        try result.appendSlice(alloc, word);
+    }
+
+    // Se não estourou, não adiciona "..."
+    if (count < n) {
+        return Value{ .string = try alloc.dupe(u8, s) };
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_truncatewords_html(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    // Similar, mas poderia fechar tags HTML — implementação avançada depois
+    return filter_truncatewords(alloc, value, arg);
+}
+
+fn filter_unordered_list(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const list = switch (value) {
+        .list => |l| l,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+    try result.appendSlice(alloc, "<ul>\n");
+
+    for (list) |item| {
+        try result.appendSlice(alloc, "<li>");
+        const str = try valueToSafeString(alloc, item);
+        try result.appendSlice(alloc, str);
+        try result.appendSlice(alloc, "</li>\n");
+    }
+
+    try result.appendSlice(alloc, "</ul>");
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_upper(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    const uppered = toUpper(alloc, s) catch s;
+    return Value{ .string = uppered };
+}
+
+fn filter_urlencode(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    for (s) |c| {
+        if (std.ascii.isAlphanumeric(c) or c == '-' or c == '_' or c == '.' or c == '~') {
+            try result.append(alloc, c);
+        } else {
+            try std.fmt.format(result.writer(alloc), "%{X:0>2}", .{c});
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_urlize(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = arg;
+    const s = try valueToSafeString(alloc, value);
+
+    var result = std.ArrayList(u8){};
+
+    var i: usize = 0;
+    while (i < s.len) {
+        const remaining = s[i..];
+        if (std.mem.startsWith(u8, remaining, "http://") or
+            std.mem.startsWith(u8, remaining, "https://") or
+            std.mem.startsWith(u8, remaining, "www."))
+        {
+            var url_end = i;
+            while (url_end < s.len and
+                !std.ascii.isWhitespace(s[url_end]) and
+                s[url_end] != '<' and s[url_end] != '>' and
+                s[url_end] != '"' and s[url_end] != '\'') : (url_end += 1)
+            {}
+            const url = s[i..url_end];
+
+            const protocol = if (std.mem.startsWith(u8, url, "www.")) "http://" else "";
+
+            try result.appendSlice(alloc, "<a href=\"");
+            try result.appendSlice(alloc, protocol);
+            try result.appendSlice(alloc, url);
+            try result.appendSlice(alloc, "\">");
+            try result.appendSlice(alloc, url);
+            try result.appendSlice(alloc, "</a>");
+
+            i = url_end;
+        } else {
+            try result.append(alloc, s[i]);
+            i += 1;
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_urlizetrunc(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const limit = switch (arg orelse Value{ .int = 40 }) {
+        .int => |i| @as(usize, @max(i, 0)),
+        else => 40,
+    };
+
+    const s = try valueToSafeString(alloc, value);
+
+    std.debug.print("{s}\n", .{value.string});
+    var result = std.ArrayList(u8){};
+
+    var i: usize = 0;
+    while (i < s.len) {
+        if (std.mem.startsWith(u8, s[i..], "http://") or std.mem.startsWith(u8, s[i..], "https://")) {
+            var url_end = i;
+            while (url_end < s.len and !std.ascii.isWhitespace(s[url_end])) : (url_end += 1) {}
+            const url = s[i..url_end];
+
+            try result.appendSlice(alloc, "<a href=\"");
+            try result.appendSlice(alloc, url);
+            try result.appendSlice(alloc, "\">");
+
+            if (url.len > limit) {
+                try result.appendSlice(alloc, url[0..limit]);
+                try result.appendSlice(alloc, "...");
+            } else {
+                try result.appendSlice(alloc, url);
+            }
+
+            try result.appendSlice(alloc, "</a>");
+
+            i = url_end;
+        } else {
+            try result.append(alloc, s[i]);
+            i += 1;
+        }
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_wordcount(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    _ = alloc;
+    _ = arg;
+    const s = switch (value) {
+        .string => |str| str,
+        else => return Value{ .int = 0 },
+    };
+
+    var count: usize = 0;
+    var in_word = false;
+    for (s) |c| {
+        if (std.ascii.isAlphanumeric(c)) {
+            if (!in_word) {
+                count += 1;
+                in_word = true;
+            }
+        } else {
+            in_word = false;
+        }
+    }
+
+    return Value{ .int = @intCast(count) };
+}
+
+fn filter_wordwrap(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const width = switch (arg orelse Value{ .int = 80 }) {
+        .int => |i| @as(usize, @max(i, 0)),
+        else => 80,
+    };
+
+    const s = switch (value) {
+        .string => |str| str,
+        else => return value,
+    };
+
+    var result = std.ArrayList(u8){};
+
+    var line_len: usize = 0;
+    var words = std.mem.splitScalar(u8, s, ' ');
+    while (words.next()) |word| {
+        const space_len: usize = if (line_len > 0) 1 else 0;
+        const needed = line_len + space_len + word.len;
+
+        if (needed > width and line_len > 0) {
+            try result.append(alloc, '\n');
+            line_len = 0;
+        }
+
+        if (line_len > 0) {
+            try result.append(alloc, ' ');
+            line_len += 1;
+        }
+
+        try result.appendSlice(alloc, word);
+        line_len += word.len;
+    }
+
+    return Value{ .string = try result.toOwnedSlice(alloc) };
+}
+
+fn filter_yesno(alloc: std.mem.Allocator, value: Value, arg: ?Value) FilterError!Value {
+    const arg_str = switch (arg orelse return error.InvalidArgument) {
+        .string => |s| s,
+        else => return error.InvalidArgument,
+    };
+
+    var parts = std.mem.splitScalar(u8, arg_str, ',');
+    var true_val: []const u8 = "yes";
+    var false_val: []const u8 = "no";
+    var none_val: []const u8 = "no";
+
+    if (parts.next()) |t| true_val = t;
+    if (parts.next()) |f| false_val = f;
+    if (parts.next()) |n| none_val = n;
+
+    const is_truthy = switch (value) {
+        .bool => |b| b,
+        .null => null,
+        .string => |s| s.len > 0,
+        .int => |i| i != 0,
+        .float => |f| f != 0.0,
+        .list => |l| l.len > 0,
+        .dict => |d| d.count() > 0,
+    };
+
+    const result_str = if (is_truthy) |b|
+        if (b) true_val else false_val
+    else
+        none_val;
+
+    const copied = try alloc.dupe(u8, result_str);
+    return Value{ .string = copied };
+}
+
+// ==================== AUX FUNCTIONS ====================
+pub fn capFirst(allocator: std.mem.Allocator, input: []const u8) ![]const u8 {
+    if (input.len == 0) return "";
+
+    const first_len = try std.unicode.utf8ByteSequenceLength(input[0]);
+    const first_codepoint = try std.unicode.utf8Decode(input[0..first_len]);
+
+    const upper_first = switch (first_codepoint) {
+        'a'...'z' => first_codepoint - 32,
+        'á' => 'Á',
+        'à' => 'À',
+        'â' => 'Â',
+        'ã' => 'Ã',
+        'ä' => 'Ä',
+        'é' => 'É',
+        'è' => 'È',
+        'ê' => 'Ê',
+        'í' => 'Í',
+        'ì' => 'Ì',
+        'î' => 'Î',
+        'ó' => 'Ó',
+        'ò' => 'Ò',
+        'ô' => 'Ô',
+        'õ' => 'Õ',
+        'ú' => 'Ú',
+        'ù' => 'Ù',
+        'û' => 'Û',
+        'ç' => 'Ç',
+        else => first_codepoint,
+    };
+
+    // ArrayList antigo, Zig 0.15 style
+    var result = std.ArrayList(u8){};
+    try result.ensureTotalCapacity(allocator, input.len);
+
+    // Escreve a primeira letra maiúscula
+    var buf: [4]u8 = undefined;
+    const bytes_written = try std.unicode.utf8Encode(upper_first, &buf);
+    try result.appendSlice(allocator, buf[0..bytes_written]);
+
+    // Copia o resto inalterado
+    try result.appendSlice(allocator, input[first_len..]);
+
+    return try result.toOwnedSlice(allocator);
+}
+
+fn toUpper(alloc: std.mem.Allocator, input: []const u8) ![]const u8 {
+    const result = try alloc.alloc(u8, input.len * 4);
+    var out_idx: usize = 0;
+
+    var i: usize = 0;
+    while (i < input.len) {
+        const len = try std.unicode.utf8ByteSequenceLength(input[i]);
+        const codepoint = try std.unicode.utf8Decode(input[i .. i + len]);
+
+        const upper = switch (codepoint) {
+            'a'...'z' => codepoint - 32,
+            'á' => 'Á',
+            'é' => 'É',
+            'í' => 'Í',
+            'ó' => 'Ó',
+            'ú' => 'Ú',
+            'ã' => 'Ã',
+            'õ' => 'Õ',
+            'ç' => 'Ç',
+            'â' => 'Â',
+            'ê' => 'Ê',
+            'î' => 'Î',
+            'ô' => 'Ô',
+            'û' => 'Û',
+            'à' => 'À',
+            'è' => 'È',
+            'ì' => 'Ì',
+            'ò' => 'Ò',
+            'ù' => 'Ù',
+            else => codepoint,
+        };
+
+        const bytes_written = try std.unicode.utf8Encode(upper, result[out_idx..]);
+        out_idx += bytes_written;
+        i += len;
+    }
+
+    return try alloc.dupe(u8, result[0..out_idx]);
+}
+
+fn toLower(alloc: std.mem.Allocator, input: []const u8) ![]const u8 {
+    const result = try alloc.alloc(u8, input.len * 4);
+    var out_idx: usize = 0;
+
+    var i: usize = 0;
+    while (i < input.len) {
+        const len = try std.unicode.utf8ByteSequenceLength(input[i]);
+        const codepoint = try std.unicode.utf8Decode(input[i .. i + len]);
+
+        const lower = switch (codepoint) {
+            'A'...'Z' => codepoint + 32,
+            'Á' => 'á',
+            'É' => 'é',
+            'Í' => 'í',
+            'Ó' => 'ó',
+            'Ú' => 'ú',
+            'Ã' => 'ã',
+            'Õ' => 'õ',
+            'Ç' => 'ç',
+            'Â' => 'â',
+            'Ê' => 'ê',
+            'Î' => 'î',
+            'Ô' => 'ô',
+            'Û' => 'û',
+            'À' => 'à',
+            'È' => 'è',
+            'Ì' => 'ì',
+            'Ò' => 'ò',
+            'Ù' => 'ù',
+            else => codepoint,
+        };
+
+        const bytes_written = try std.unicode.utf8Encode(lower, result[out_idx..]);
+        out_idx += bytes_written;
+        i += len;
+    }
+
+    return try alloc.dupe(u8, result[0..out_idx]);
+}
+
+fn valueToSafeString(alloc: std.mem.Allocator, value: Value) FilterError![]const u8 {
+    return switch (value) {
+        .string => |s| s,
+        .int => |i| try std.fmt.allocPrint(alloc, "{d}", .{i}),
+        .float => |f| try std.fmt.allocPrint(alloc, "{d}", .{f}),
+        .bool => |b| if (b) "true" else "false",
+        .null => "null",
+        else => "[object]", // list, dict → literal, não aloca
+    };
+}
+
+// ==================== MAPA DE FILTROS BUILTIN ====================
+
+pub const builtin_filters = std.StaticStringMap(*const FilterFn).initComptime(.{
+    .{ "add", &filter_add },
+    .{ "addslashes", &filter_addslashes },
+    .{ "capfirst", &filter_capfirst },
+    .{ "center", &filter_center },
+    .{ "cut", &filter_cut },
+    // .{ "date", &filter_date },
+    .{ "default", &filter_default },
+    .{ "default_if_none", &filter_default_if_none },
+    .{ "dictsort", &filter_dictsort },
+    .{ "dictsortreversed", &filter_dictsortreversed },
+    .{ "divisibleby", &filter_divisibleby },
+    .{ "escape", &filter_escape },
+    .{ "escapejs", &filter_escapejs },
+    .{ "escapeseq", &filter_escapeseq },
+    .{ "filesizeformat", &filter_filesizeformat },
+    .{ "first", &filter_first },
+    .{ "floatformat", &filter_floatformat },
+    .{ "force_escape", &filter_force_escape },
+    .{ "get_digit", &filter_get_digit },
+    .{ "iriencode", &filter_iriencode },
+    .{ "join", &filter_join },
+    .{ "json_script", &filter_json_script },
+    .{ "last", &filter_last },
+    .{ "length", &filter_length },
+    .{ "linebreaks", &filter_linebreaks },
+    .{ "linebreaksbr", &filter_linebreaksbr },
+    .{ "linenumbers", &filter_linenumbers },
+    .{ "ljust", &filter_ljust },
+    .{ "lower", &filter_lower },
+    .{ "make_list", &filter_make_list },
+    .{ "phone2numeric", &filter_phone2numeric },
+    .{ "pluralize", &filter_pluralize },
+    .{ "pprint", &filter_pprint },
+    .{ "random", &filter_random },
+    .{ "rjust", &filter_rjust },
+    .{ "safe", &filter_safe },
+    .{ "safeseq", &filter_safeseq },
+    .{ "slice", &filter_slice },
+    .{ "slugify", &filter_slugify },
+    .{ "stringformat", &filter_stringformat },
+    .{ "striptags", &filter_striptags },
+    // .{ "time", &filter_time },
+    // .{ "timesince", &filter_timesince },
+    // .{ "timeuntil", &filter_timeuntil },
+    .{ "title", &filter_title },
+    .{ "truncatechars", &filter_truncatechars },
+    .{ "truncatechars_html", &filter_truncatechars_html },
+    .{ "truncatewords", &filter_truncatewords },
+    .{ "truncatewords_html", &filter_truncatewords_html },
+    .{ "unordered_list", &filter_unordered_list },
+    .{ "upper", &filter_upper },
+    .{ "urlencode", &filter_urlencode },
+    .{ "urlize", &filter_urlize },
+    .{ "urlizetrunc", &filter_urlizetrunc },
+    .{ "wordwrap", &filter_wordwrap },
+    .{ "wordcount", &filter_wordcount },
+    .{ "yesno", &filter_yesno },
+});
diff --git a/src/filters_test.zig b/src/filters_test.zig
new file mode 100644
index 0000000..c5fe77d
--- /dev/null
+++ b/src/filters_test.zig
@@ -0,0 +1,742 @@
+const std = @import("std");
+const testing = std.testing;
+const Value = @import("context.zig").Value;
+const Context = @import("context.zig").Context;
+const builtin_filters = @import("filters.zig").builtin_filters;
+const FilterError = @import("filters.zig").FilterError;
+const std_time = std.time;
+
+test "filters upper/lower, capfirst" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("texto", "é ação é nóis, você çãõ");
+
+    const v = ctx.get("texto").?;
+
+    const lower = builtin_filters.get("lower").?;
+    const upper = builtin_filters.get("upper").?;
+    const capfirst = builtin_filters.get("capfirst").?;
+
+    const lowered = try lower(ctx.allocator(), v, null);
+    const uppered = try upper(ctx.allocator(), v, null);
+    const capped = try capfirst(ctx.allocator(), v, null);
+
+    try testing.expectEqualStrings("é ação é nóis, você çãõ", lowered.string);
+    try testing.expectEqualStrings("É AÇÃO É NÓIS, VOCÊ ÇÃÕ", uppered.string);
+    try testing.expectEqualStrings("É ação é nóis, você çãõ", capped.string);
+}
+
+test "builtin filters - add" {
+    const alloc = testing.allocator;
+    const add = builtin_filters.get("add").?;
+
+    const v_int = Value{ .int = 10 };
+    const v_float = Value{ .float = 5.5 };
+
+    const arg_int = Value{ .int = 20 };
+    const arg_float = Value{ .float = 4.5 };
+    const arg_int_to_float = Value{ .int = 5 };
+
+    const result_int = try add(alloc, v_int, arg_int);
+    const result_float_from_int = try add(alloc, v_int, arg_float);
+    const result_float_add_int = try add(alloc, v_float, arg_int_to_float);
+
+    try testing.expect(result_int.int == 30);
+    try testing.expectApproxEqAbs(14.5, result_float_from_int.float, 0.0001);
+    try testing.expectApproxEqAbs(10.5, result_float_add_int.float, 0.0001);
+}
+
+test "builtin filters - default and default_if_none" {
+    const alloc = testing.allocator;
+    const default_filter = builtin_filters.get("default").?;
+    const default_if_none = builtin_filters.get("default_if_none").?;
+
+    const empty_str = Value{ .string = "" };
+    const null_val = Value.null;
+    const non_empty = Value{ .string = "existe" };
+    const empty_list = Value{ .list = &.{} };
+
+    const def = Value{ .string = "padrão" };
+
+    // default
+    try testing.expectEqualStrings("padrão", (try default_filter(alloc, empty_str, def)).string);
+    try testing.expectEqualStrings("padrão", (try default_filter(alloc, empty_list, def)).string);
+    try testing.expectEqualStrings("existe", (try default_filter(alloc, non_empty, def)).string);
+    try testing.expectEqualStrings("padrão", (try default_filter(alloc, null_val, def)).string);
+
+    // default_if_none
+    try testing.expectEqualStrings("padrão", (try default_if_none(alloc, null_val, def)).string);
+    try testing.expectEqualStrings("", (try default_if_none(alloc, empty_str, def)).string);
+    try testing.expectEqualStrings("existe", (try default_if_none(alloc, non_empty, def)).string);
+}
+
+test "builtin filters - length" {
+    const alloc = testing.allocator;
+    const length = builtin_filters.get("length").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("abc", "abc");
+    try ctx.set("empty", "");
+
+    const numbers = [_]i64{ 1, 2, 3, 4 };
+    try ctx.set("list", numbers);
+
+    const str_val = ctx.get("abc").?;
+    const empty_str = ctx.get("empty").?;
+    const list_val = ctx.get("list").?;
+
+    try testing.expect((try length(ctx.allocator(), str_val, null)).int == 3);
+    try testing.expect((try length(ctx.allocator(), empty_str, null)).int == 0);
+    try testing.expect((try length(ctx.allocator(), list_val, null)).int == 4);
+}
+
+test "builtin filters - length com dict" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("config.chave1", "valor1");
+    try ctx.set("config.chave2", 42);
+
+    var dict = std.StringHashMapUnmanaged(Value){};
+    try dict.put(ctx.allocator(), "a", Value{ .int = 10 });
+    try dict.put(ctx.allocator(), "b", Value{ .bool = true });
+
+    const v = Value{ .dict = dict };
+    const length = builtin_filters.get("length").?;
+
+    const len = try length(ctx.allocator(), v, null);
+    try testing.expect(len.int == 2);
+}
+
+test "builtin filters - first and last" {
+    const alloc = testing.allocator;
+    const first = builtin_filters.get("first").?;
+    const last = builtin_filters.get("last").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    const list = [_][]const u8{ "um", "dois", "três" };
+    try ctx.set("list", list);
+
+    const str_val = Value{ .string = "abc" };
+    const empty_str = Value{ .string = "" };
+    const empty_list = Value{ .list = &.{} };
+    const list_val = ctx.get("list").?;
+
+    // first
+    try testing.expectEqualStrings("um", (try first(alloc, list_val, null)).string);
+    try testing.expectEqualStrings("a", (try first(alloc, str_val, null)).string);
+    try testing.expect((try first(alloc, empty_str, null)) == .null);
+    try testing.expect((try first(alloc, empty_list, null)) == .null);
+
+    // last
+    try testing.expectEqualStrings("três", (try last(alloc, list_val, null)).string);
+    try testing.expectEqualStrings("c", (try last(alloc, str_val, null)).string);
+    try testing.expect((try last(alloc, empty_str, null)) == .null);
+    try testing.expect((try last(alloc, empty_list, null)) == .null);
+}
+
+test "builtin filters - join" {
+    const alloc = testing.allocator;
+    const join = builtin_filters.get("join").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    const list = [_][]const u8{ "a", "b", "c" };
+    try ctx.set("list", list);
+
+    const list_val = ctx.get("list").?;
+    const sep_dash = Value{ .string = "-" };
+
+    const mixed = [_]Value{ Value{ .string = "x" }, Value{ .int = 42 }, Value{ .bool = true } };
+    try ctx.set("mixed", mixed);
+    const mixed_val = ctx.get("mixed").?;
+
+
+    const default_join = try join(ctx.allocator(), list_val, null);
+    const custom_join = try join(ctx.allocator(), list_val, sep_dash);
+    const mixed_join = try join(ctx.allocator(), mixed_val, null);
+
+    try testing.expectEqualStrings("a,b,c", default_join.string);
+    try testing.expectEqualStrings("a-b-c", custom_join.string);
+    try testing.expectEqualStrings("x,42,true", mixed_join.string);
+}
+
+test "builtin filters - yesno" {
+    const alloc = testing.allocator;
+    const yesno = builtin_filters.get("yesno").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    const cases = [_]struct { val: Value, arg: []const u8, expected: []const u8 }{
+        .{ .val = Value{ .bool = true }, .arg = "sim,não,talvez", .expected = "sim" },
+        .{ .val = Value{ .bool = false }, .arg = "sim,não,talvez", .expected = "não" },
+        .{ .val = Value.null, .arg = "sim,não,talvez", .expected = "talvez" },
+        .{ .val = Value{ .string = "" }, .arg = "sim,não", .expected = "não" },
+        .{ .val = Value{ .string = "oi" }, .arg = "sim,não", .expected = "sim" },
+    };
+
+    for (cases) |case| {
+        const arg_val = Value{ .string = case.arg };
+        const result = try yesno(ctx.allocator(), case.val, arg_val);
+        try testing.expectEqualStrings(case.expected, result.string);
+    }
+}
+
+test "builtin filters - truncatechars and truncatechars_html" {
+    const alloc = testing.allocator;
+    const truncatechars = builtin_filters.get("truncatechars").?;
+    const truncatechars_html = builtin_filters.get("truncatechars_html").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("longo", "abcdefghijkl"); // 12 chars
+    try ctx.set("empty", "");
+
+    const v = ctx.map.get("longo").?;
+
+    const tc10 = try truncatechars(ctx.allocator(), v, Value{ .int = 10 });
+    const tc5 = try truncatechars(ctx.allocator(), v, Value{ .int = 5 });
+    const tc3 = try truncatechars(ctx.allocator(), v, Value{ .int = 3 });
+
+    try testing.expectEqualStrings("abcdefg...", tc10.string); // 7 + "..."
+    try testing.expectEqualStrings("ab...", tc5.string); // 2 + "..."
+    try testing.expectEqualStrings("", tc3.string); // n < 3 → ""
+
+    // truncatechars_html similar por enquanto
+    const tc_html10 = try truncatechars_html(ctx.allocator(), v, Value{ .int = 10 });
+    try testing.expectEqualStrings("abcdefg...", tc_html10.string);
+}
+
+test "builtin filters - truncatewords" {
+    const alloc = testing.allocator;
+    const truncatewords = builtin_filters.get("truncatewords").?;
+    const truncatewords_html = builtin_filters.get("truncatewords_html").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("longo", "Este é um texto muito longo para ser truncado");
+
+    const v = ctx.get("longo").?;
+
+    const tw5 = try truncatewords(ctx.allocator(), v, Value{ .int = 5 });
+    const tw3 = try truncatewords(ctx.allocator(), v, Value{ .int = 3 });
+
+    try testing.expectEqualStrings("Este é um texto muito...", tw5.string);
+    try testing.expectEqualStrings("Este é um...", tw3.string);
+    //
+    // truncatechars_html similar por enquanto
+    const tc_html10 = try truncatewords_html(ctx.allocator(), v, Value{ .int = 6 });
+    try testing.expectEqualStrings("Este é um texto muito longo...", tc_html10.string);
+}
+
+test "builtin filters - slice" {
+    const alloc = testing.allocator;
+    const slice = builtin_filters.get("slice").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    const list = try alloc.alloc(Value, 5);
+    defer alloc.free(list);
+    for (list, 0..) |*item, i| item.* = Value{ .int = @intCast(i + 1) };
+
+    try ctx.set("nums", Value{ .list = list });
+    try ctx.set("texto", "abcdef");
+
+    const v_list = ctx.get("nums").?;
+    const v_str = ctx.get("texto").?;
+
+    const slice2 = try slice(ctx.allocator(), v_list, Value{ .string = ":2" });
+    const slice13 = try slice(ctx.allocator(), v_str, Value{ .string = "1:3" });
+
+    try testing.expect(slice2.list.len == 2);
+    try testing.expect(slice2.list[0].int == 1);
+    try testing.expect(slice2.list[1].int == 2);
+    try testing.expectEqualStrings("bc", slice13.string);
+}
+
+test "builtin filters - safe and force_escape" {
+    const alloc = testing.allocator;
+    const safe = builtin_filters.get("safe").?;
+    const force_escape = builtin_filters.get("force_escape").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("html", "<script>alert('xss')</script>");
+
+    const v = ctx.get("html").?;
+
+    const escaped = try force_escape(ctx.allocator(), v, null);
+    try testing.expectEqualStrings("&lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;", escaped.string);
+
+    // safe retorna o mesmo (o renderer vai tratar como seguro)
+    const safed = try safe(ctx.allocator(), v, null);
+    try testing.expectEqualStrings("<script>alert('xss')</script>", safed.string);
+}
+
+test "builtin filters - linebreaksbr and linebreaks" {
+    const alloc = testing.allocator;
+    const linebreaksbr = builtin_filters.get("linebreaksbr").?;
+    const linebreaks = builtin_filters.get("linebreaks").?;
+
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("texto", "Linha 1\nLinha 2\n\nLinha 3");
+
+    const v = ctx.get("texto").?;
+
+    const br = try linebreaksbr(ctx.allocator(), v, null);
+    const p = try linebreaks(ctx.allocator(), v, null);
+
+    try testing.expect(std.mem.indexOf(u8, br.string, "<br>") != null);
+    try testing.expect(std.mem.indexOf(u8, p.string, "<p>") != null);
+}
+
+test "builtin filters - escape and force_escape" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("xss", "<script>alert('xss')</script>");
+
+    const v = ctx.get("xss").?;
+
+    const escape = builtin_filters.get("escape").?;
+    const force_escape = builtin_filters.get("force_escape").?;
+
+    const escaped = try escape(ctx.allocator(), v, null);
+    const forced = try force_escape(ctx.allocator(), v, null);
+
+    const expected = "&lt;script&gt;alert(&#x27;xss&#x27;)&lt;/script&gt;";
+    try testing.expectEqualStrings(expected, escaped.string);
+    try testing.expectEqualStrings(expected, forced.string);
+}
+
+test "builtin filters - striptags" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("html", "<p>Olá <b>mundo</b> legal!</p>");
+
+    const v = ctx.get("html").?;
+
+    const striptags = builtin_filters.get("striptags").?;
+    const stripped = try striptags(ctx.allocator(), v, null);
+
+    try testing.expectEqualStrings("Olá mundo legal!", stripped.string);
+}
+
+test "builtin filters - slugify" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("titulo", "Olá Mundo Legal!!! 2026 ações");
+
+    const v = ctx.get("titulo").?;
+
+    const slugify = builtin_filters.get("slugify").?;
+    const slugged = try slugify(ctx.allocator(), v, null);
+
+    try testing.expectEqualStrings("ola-mundo-legal-2026-acoes", slugged.string);
+}
+
+test "builtin filters - floatformat" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("pi", 3.14159);
+    try ctx.set("e", 2.71828);
+    try ctx.set("inteiro", 42);
+
+    const v_pi = ctx.get("pi").?;
+    const v_e = ctx.get("e").?;
+    const v_int = ctx.get("inteiro").?;
+
+    const floatformat = builtin_filters.get("floatformat").?;
+
+    const default_pi = try floatformat(ctx.allocator(), v_pi, null);
+    const pi_2 = try floatformat(ctx.allocator(), v_pi, Value{ .int = 2 });
+    const pi_0 = try floatformat(ctx.allocator(), v_pi, Value{ .int = 0 });
+    const int_1 = try floatformat(ctx.allocator(), v_int, Value{ .int = 1 });
+    const ve = try floatformat(ctx.allocator(), v_e, Value{ .int = 2 });
+
+    try testing.expectEqualStrings("3.14159", default_pi.string);
+    try testing.expectEqualStrings("3.14", pi_2.string);
+    try testing.expectEqualStrings("3", pi_0.string);
+    try testing.expectEqualStrings("42.0", int_1.string);
+    try testing.expectEqualStrings("2.72", ve.string);
+}
+
+test "builtin filters - stringformat" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("nome", "Lucas");
+    try ctx.set("idade", 30);
+
+    const v_nome = ctx.get("nome").?;
+    const v_idade = ctx.get("idade").?;
+
+    const stringformat = builtin_filters.get("stringformat").?;
+
+    const fmt_nome = try stringformat(ctx.allocator(), v_nome, Value{ .string = "Olá %s!" });
+    const fmt_idade = try stringformat(ctx.allocator(), v_idade, Value{ .string = "Idade: %d anos" });
+
+    try testing.expectEqualStrings("Olá Lucas!", fmt_nome.string);
+    try testing.expectEqualStrings("Idade: 30 anos", fmt_idade.string);
+}
+
+test "builtin filters - cut" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("texto", "Olá mundo cruel, mundo!");
+
+    const v = ctx.get("texto").?;
+
+    const cut = builtin_filters.get("cut").?;
+    const cut_mundo = try cut(ctx.allocator(), v, Value{ .string = "mundo" });
+
+    try testing.expectEqualStrings("Olá  cruel, !", cut_mundo.string);
+}
+
+test "builtin filters - title" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("texto", "olá mundo cruel");
+
+    const v = ctx.get("texto").?;
+
+    const title = builtin_filters.get("title").?;
+    const titled = try title(ctx.allocator(), v, null);
+
+    try testing.expectEqualStrings("Olá Mundo Cruel", titled.string);
+}
+
+test "builtin filters - wordcount" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("frase", "Este é um texto com exatamente sete palavras");
+
+    const v = ctx.get("frase").?;
+
+    const wordcount = builtin_filters.get("wordcount").?;
+    const count = try wordcount(ctx.allocator(), v, null);
+
+    try testing.expect(count.int == 7);
+}
+
+test "builtin filters - urlencode" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("query", "busca=zig lang&pagina=1");
+
+    const v = ctx.get("query").?;
+
+    const urlencode = builtin_filters.get("urlencode").?;
+    const encoded = try urlencode(ctx.allocator(), v, null);
+
+    try testing.expectEqualStrings("busca%3Dzig%20lang%26pagina%3D1", encoded.string);
+}
+
+test "builtin filters - pluralize" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("voto", 1);
+    try ctx.set("votos", 5);
+    // try ctx.set("zero", 0);
+
+    const v1 = ctx.get("voto").?;
+    const v5 = ctx.get("votos").?;
+    // const v0 = ctx.get("zero").?;
+
+    const pluralize = builtin_filters.get("pluralize").?;
+
+    const s1 = try pluralize(ctx.allocator(), v1, null);
+    const s5 = try pluralize(ctx.allocator(), v5, null);
+    const custom = try pluralize(ctx.allocator(), v5, Value{ .string = "es" });
+    // const zero = try pluralize(ctx.allocator(), v0, null);
+
+    try testing.expectEqualStrings("", s1.string); // 1 → singular (vazio)
+    try testing.expectEqualStrings("s", s5.string); // 5 → plural
+    try testing.expectEqualStrings("es", custom.string);
+    // try testing.expectEqualStrings("", zero.string);
+}
+
+test "builtin filters - addslashes, center, date" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("quote", "He's a good boy");
+    try ctx.set("texto", "zig");
+
+    const v_quote = ctx.get("quote").?;
+    const v_texto = ctx.get("texto").?;
+
+    const addslashes = builtin_filters.get("addslashes").?;
+    const center = builtin_filters.get("center").?;
+    // const date = builtin_filters.get("date").?;
+
+    const slashed = try addslashes(ctx.allocator(), v_quote, null);
+    const centered = try center(ctx.allocator(), v_texto, Value{ .int = 10 });
+    // const formatted = try date(ctx.allocator(), Value{ .int = 0 }, Value{ .string = "Y-m-d" });
+
+    try testing.expectEqualStrings("He\\'s a good boy", slashed.string);
+    try testing.expectEqualStrings("   zig    ", centered.string);
+    // try testing.expect(std.mem.startsWith(u8, formatted.string, "2026"));
+}
+
+test "builtin filters - dictsort and dictsortreversed" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    var dict = std.StringHashMapUnmanaged(Value){};
+    try dict.put(ctx.allocator(), "b", Value{ .int = 2 });
+    try dict.put(ctx.allocator(), "a", Value{ .int = 1 });
+    try dict.put(ctx.allocator(), "c", Value{ .int = 3 });
+
+    const v = Value{ .dict = dict };
+
+    const dictsort = builtin_filters.get("dictsort").?;
+    const dictsortreversed = builtin_filters.get("dictsortreversed").?;
+
+    const sorted = try dictsort(ctx.allocator(), v, null);
+    const reversed = try dictsortreversed(ctx.allocator(), v, null);
+
+    const sorted_list = sorted.list;
+    try testing.expect(sorted_list.len == 3);
+    try testing.expectEqualStrings("a", sorted_list[0].dict.get("key").?.string);
+    try testing.expectEqualStrings("b", sorted_list[1].dict.get("key").?.string);
+    try testing.expectEqualStrings("c", sorted_list[2].dict.get("key").?.string);
+
+    const reversed_list = reversed.list;
+    try testing.expectEqualStrings("c", reversed_list[0].dict.get("key").?.string);
+    try testing.expectEqualStrings("b", reversed_list[1].dict.get("key").?.string);
+    try testing.expectEqualStrings("a", reversed_list[2].dict.get("key").?.string);
+}
+
+test "builtin filters - divisibleby, escapejs, filesizeformat, get_digit, json_script" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    const divisibleby = builtin_filters.get("divisibleby").?;
+    const escapejs = builtin_filters.get("escapejs").?;
+    const filesizeformat = builtin_filters.get("filesizeformat").?;
+    const get_digit = builtin_filters.get("get_digit").?;
+    const json_script = builtin_filters.get("json_script").?;
+
+    const div = try divisibleby(ctx.allocator(), Value{ .int = 10 }, Value{ .int = 5 });
+    const div_2 = try divisibleby(ctx.allocator(), Value{ .int = 10 }, Value{ .int = 3 });
+    try testing.expect(div.bool == true);
+    try testing.expect(div_2.bool == false);
+
+    const js = try escapejs(ctx.allocator(), Value{ .string = "<script>alert('oi')</script>" }, null);
+    try testing.expectEqualStrings("\\<script\\>alert(\\'oi\\')\\</script\\>", js.string);
+
+    const size = try filesizeformat(ctx.allocator(), Value{ .int = 1500000 }, null);
+    try testing.expect(std.mem.indexOf(u8, size.string, "MB") != null);
+
+    const digit = try get_digit(ctx.allocator(), Value{ .int = 12345 }, Value{ .int = 2 });
+    try testing.expect(digit.int == 4);
+
+    const digit_3 = try get_digit(ctx.allocator(), Value{ .int = 123456789 }, Value{ .int = 11 });
+    try testing.expect(digit_3.int == 0);
+
+    const digit_2 = try get_digit(ctx.allocator(), Value{ .string = "baz" }, Value{ .int = 2 });
+    try testing.expect(std.mem.eql(u8, digit_2.string, "baz"));
+
+    const json = try json_script(ctx.allocator(), Value{ .string = "<b>negrito</b>" }, null);
+    try testing.expect(std.mem.indexOf(u8, json.string, "\\u003C") != null);
+}
+
+test "builtin filters - escapeseq, iriencode, linenumbers" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("texto", "Hello \"world\"\\n");
+
+    const v = ctx.get("texto").?;
+
+    const escapeseq = builtin_filters.get("escapeseq").?;
+    const iriencode = builtin_filters.get("iriencode").?;
+    const linenumbers = builtin_filters.get("linenumbers").?;
+
+    const escaped = try escapeseq(ctx.allocator(), v, null);
+    const encoded = try iriencode(ctx.allocator(), v, null);
+    const numbered = try linenumbers(ctx.allocator(), Value{ .string = "linha1\nlinha2\nlinha3" }, null);
+
+    try testing.expect(std.mem.indexOf(u8, escaped.string, "\\\"") != null);
+    try testing.expect(std.mem.indexOf(u8, encoded.string, "%20") != null);
+    try testing.expect(std.mem.indexOf(u8, numbered.string, "1. linha1") != null);
+}
+
+test "builtin filters - ljust, rjust, center" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("texto", "zig");
+
+    const v = ctx.get("texto").?;
+
+    const ljust = builtin_filters.get("ljust").?;
+    const rjust = builtin_filters.get("rjust").?;
+    const center = builtin_filters.get("center").?;
+
+    const left = try ljust(ctx.allocator(), v, Value{ .int = 10 });
+    const right = try rjust(ctx.allocator(), v, Value{ .int = 10 });
+    const centered = try center(ctx.allocator(), v, Value{ .int = 10 });
+
+    try testing.expectEqualStrings("zig       ", left.string);
+    try testing.expectEqualStrings("       zig", right.string);
+    try testing.expectEqualStrings("   zig    ", centered.string);
+}
+
+test "builtin filters - make_list, phone2numeric, pprint" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("palavra", "zig");
+    try ctx.set("telefone", "1-800-FLOWERS");
+
+    const v_palavra = ctx.get("palavra").?;
+    const v_telefone = ctx.get("telefone").?;
+
+    const make_list = builtin_filters.get("make_list").?;
+    const phone2numeric = builtin_filters.get("phone2numeric").?;
+    const pprint = builtin_filters.get("pprint").?;
+
+    const list = try make_list(ctx.allocator(), v_palavra, null);
+    const numeric = try phone2numeric(ctx.allocator(), v_telefone, null);
+    const printed = try pprint(ctx.allocator(), Value{ .int = 42 }, null);
+
+    try testing.expect(list.list.len == 3);
+    try testing.expectEqualStrings("z", list.list[0].string);
+    try testing.expect(std.mem.indexOf(u8, numeric.string, "3569377") != null);
+    try testing.expect(std.mem.indexOf(u8, printed.string, "42") != null);
+}
+
+test "builtin filters - random, safeseq" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    var items = try alloc.alloc(Value, 3);
+    defer alloc.free(items);
+    items[0] = Value{ .string = "a" };
+    items[1] = Value{ .string = "b" };
+    items[2] = Value{ .string = "c" };
+
+    const v = Value{ .list = items };
+
+    const random = builtin_filters.get("random").?;
+    const safeseq = builtin_filters.get("safeseq").?;
+
+    const rand = try random(ctx.allocator(), v, null);
+    const safe = try safeseq(ctx.allocator(), v, null);
+
+    try testing.expect(rand == .string);
+    try testing.expect(safe == .list);
+}
+
+// test "builtin filters - date, time, timesince, timeuntil" {
+//     const alloc = testing.allocator;
+//     var ctx = Context.init(alloc);
+//     defer ctx.deinit();
+//
+//     const now = std_time.timestamp();
+//
+//     // const date = builtin_filters.get("date").?;
+//     const time = builtin_filters.get("time").?;
+//     const timesince = builtin_filters.get("timesince").?;
+//     // const timeuntil = builtin_filters.get("timeuntil").?;
+//
+//     // const d = try date(ctx.allocator(), Value{ .int = now }, Value{ .string = "d/m/Y" });
+//     const t = try time(ctx.allocator(), Value{ .int = now }, Value{ .string = "H:i" });
+//
+//     // try testing.expect(d.string.len > 0);
+//     try testing.expect(t.string.len > 0);
+//
+//     const since = try timesince(ctx.allocator(), Value{ .int = now - 3600 }, null);
+//     try testing.expect(std.mem.indexOf(u8, since.string, "hora") != null);
+// }
+
+test "builtin filters - urlize, urlizetrunc, wordwrap, unordered_list" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+    try ctx.set("url", "Visite https://ziglang.org");
+
+    const v_url = ctx.get("url").?;
+
+    const urlize = builtin_filters.get("urlize").?;
+    const urlizetrunc = builtin_filters.get("urlizetrunc").?;
+    const wordwrap = builtin_filters.get("wordwrap").?;
+
+    const u = try urlize(ctx.allocator(), v_url, null);
+    try testing.expect(std.mem.indexOf(u8, u.string, "<a href=") != null);
+
+    const ut = try urlizetrunc(ctx.allocator(), v_url, Value{ .int = 10 });
+    try testing.expect(std.mem.indexOf(u8, ut.string, "...") != null);
+
+    const long_text = "Este é um texto muito longo que precisa ser quebrado em várias linhas para caber na largura especificada";
+    const wrapped = try wordwrap(ctx.allocator(), Value{ .string = long_text }, Value{ .int = 20 });
+    try testing.expect(std.mem.indexOf(u8, wrapped.string, "\n") != null);
+
+}
+
+test "builtin filters - unordered_list" {
+    const alloc = testing.allocator;
+    var ctx = Context.init(alloc);
+    defer ctx.deinit();
+
+
+    const list = [_]Value{ Value{ .string = "item1" }, Value{ .string = "item2" } };
+    try ctx.set("lista", list);
+
+    const v = ctx.get("lista").?;
+
+    const unordered_list = builtin_filters.get("unordered_list").?;
+    const ul = try unordered_list(ctx.allocator(), v, null);
+
+    const expected =
+        \\<ul>
+        \\<li>item1</li>
+        \\<li>item2</li>
+        \\</ul>
+    ;
+    std.debug.print("lista gerada: {any}\n", .{ul.string});
+    try testing.expectEqualStrings(expected, ul.string);
+}
diff --git a/todo.md b/todo.md
index c7cd2be..2ef6247 100644
--- a/todo.md
+++ b/todo.md
@@ -31,63 +31,63 @@
 
 # Filters
 
-- [ ] add
-- [ ] addslashes
-- [ ] capfirst
-- [ ] center
-- [ ] cut
+- [x] add
+- [x] addslashes
+- [x] capfirst
+- [x] center
+- [x] cut
 - [ ] date
-- [ ] default
-- [ ] default_if_none
-- [ ] dictsort
-- [ ] dictsortreversed
-- [ ] divisibleby
-- [ ] escape
-- [ ] escapejs
-- [ ] escapeseq
-- [ ] filesizeformat
-- [ ] first
-- [ ] floatformat
-- [ ] force_escape
-- [ ] get_digit
-- [ ] iriencode
-- [ ] join
-- [ ] json_script
-- [ ] last
-- [ ] length
-- [ ] linebreaks
-- [ ] linebreaksbr
-- [ ] linenumbers
-- [ ] ljust
-- [ ] lower
-- [ ] make_list
-- [ ] phone2numeric
-- [ ] pluralize
-- [ ] pprint
-- [ ] random
-- [ ] rjust
-- [ ] safe
-- [ ] safeseq
-- [ ] slice
-- [ ] slugify
-- [ ] stringformat
-- [ ] striptags
+- [x] default
+- [x] default_if_none
+- [x] dictsort
+- [x] dictsortreversed
+- [x] divisibleby
+- [x] escape
+- [x] escapejs
+- [x] escapeseq
+- [x] filesizeformat
+- [x] first
+- [x] floatformat
+- [x] force_escape
+- [x] get_digit
+- [x] iriencode
+- [x] join
+- [x] json_script
+- [x] last
+- [x] length
+- [x] linebreaks
+- [x] linebreaksbr
+- [x] linenumbers
+- [x] ljust
+- [x] lower
+- [x] make_list
+- [x] phone2numeric
+- [x] pluralize
+- [x] pprint
+- [x] random
+- [x] rjust
+- [x] safe
+- [x] safeseq
+- [x] slice
+- [x] slugify
+- [x] stringformat
+- [x] striptags
 - [ ] time
 - [ ] timesince
 - [ ] timeuntil
-- [ ] title
-- [ ] truncatechars
-- [ ] truncatechars_html
-- [ ] truncatewords
-- [ ] truncatewords_html
-- [ ] unordered_list
-- [ ] upper
-- [ ] urlencode
-- [ ] urlize
-- [ ] urlizetrunc
-- [ ] wordcount
-- [ ] wordwrap
-- [ ] yesno
+- [x] title
+- [x] truncatechars
+- [-] truncatechars_html
+- [x] truncatewords
+- [-] truncatewords_html
+- [x] unordered_list
+- [x] upper
+- [x] urlencode
+- [x] urlize
+- [x] urlizetrunc
+- [x] wordcount
+- [x] wordwrap
+- [x] yesno
 
 ___
 
@@ -131,3 +131,87 @@ ___
 - Tudo testado
 
 4 -Filtros
+
+
+
+
+
+na verdade o pushScope não tava não, a versão final que vc me mandou depois que se inspirou no tokamak foi essa:
+```
+const std = @import("std");
+
+pub const Value = union(enum) {
+    null,
+    bool: bool,
+    int: i64,
+    float: f64,
+    string: []const u8,
+    list: []const Value,
+    dict: std.StringHashMapUnmanaged(Value),
+
+    pub fn deinit(self: Value) void {
+        _ = self; // nada — a arena libera tudo
+    }
+};
+
+pub const Context = struct {
+    arena: std.heap.ArenaAllocator,
+    map: std.StringHashMapUnmanaged(Value),
+
+    pub fn init(child_allocator: std.mem.Allocator) Context {
+        const arena = std.heap.ArenaAllocator.init(child_allocator);
+        return .{
+            .arena = arena,
+            .map = .{},
+        };
+    }
+
+    pub fn allocator(self: *Context) std.mem.Allocator {
+        return self.arena.allocator();
+    }
+
+    pub fn deinit(self: *Context) void {
+        self.arena.deinit();
+    }
+
+    pub fn set(self: *Context, key: []const u8, value: Value) !void {
+        const gop = try self.map.getOrPut(self.allocator(), key);
+        if (gop.found_existing) {
+            // opcional: deinit value antigo se necessário
+            // mas como arena libera tudo, não precisa
+        } else {
+            gop.key_ptr.* = try self.allocator().dupe(u8, key);
+        }
+        gop.value_ptr.* = value;
+    }
+
+    pub fn get(self: *const Context, key: []const u8) ?Value {
+        return self.map.get(key);
+    }
+};
+
+```
+ao colocar isso ordered_dict: []struct { key: []const u8, val: Value }, vc ferrou em todos os switches de Value que agora tem que prever o que fazer com orderdered_dict
+
+Conclusão sobre o getA melhor abordagem, considerando Zig, é:
+Manter o get(comptime T: type, key) — é seguro, performático, e em uso real fica natural
+
+```zig
+const idade: i64 = ctx.get("idade") orelse 0;
+const nome: []const u8 = ctx.get("nome") orelse "Desconhecido";
+```
+
+É verboso no teste, mas em código real é claro e seguro.Ou podemos fazer uma versão com optional:
+
+```zig
+pub fn get(self: *const Context, comptime T: type, key: []const u8) ?T {
+    const value = self.map.get(key) orelse return null;
+    return value.as(T) catch null;
+}
+```
+
+Aí fica:
+
+```zig
+const idade = ctx.get(i64, "idade") orelse 0;
+```