Fix memory leaks found by DebugAllocator.

Use leak detection of DebugAllocator.
When allocating memory it remebers where memory was allocated but it only for leaks in .deinit(). So not calling it is a sure way to miss a bunch of leaks. deinit() returns if it found leaks but we don't really care. Its usefull for tests but not here.
2026-03-04 02:00:40 +03:00 · 2026-03-04 02:00:40 +03:00 · 2026-03-04 02:00:40 +03:00 · 2026-03-04 02:00:40 +03:00 · 2026-03-04 02:00:40 +03:00 · 2026-03-04 02:00:40 +03:00
37 changed files with 795 additions and 822 deletions
--- a/build.zig
+++ b/build.zig
@@ -8,8 +8,8 @@ pub fn build(b: *std.Build) void {

    const exe = b.addExecutable(.{
        .name = "Zivro",
-        .use_llvm = true,
-        .use_lld = true,
+        // .use_llvm = true,
+        // .use_lld = true,
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -33,8 +33,8 @@
    // internet connectivity.
    .dependencies = .{
        .dvui = .{
-            .url = "https://github.com/david-vanderson/dvui/archive/main.tar.gz",
-            .hash = "dvui-0.4.0-dev-AQFJmev72QC6e0ojhnW8a_wRhZDgzWWLgeyoNuIPZc2m",
+            .url = "git+https://github.com/david-vanderson/dvui#edb2d5a4cd2981fca74ee5f096277b91333c1316",
+            .hash = "dvui-0.4.0-dev-AQFJmeGB3QAwun9qF76CDE5IopA4nUVRgD-IwwTsOo4H",
        },

        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
--- a/review.txt
+++ b/review.txt
--- a/src/Canvas.zig
+++ b/src/Canvas.zig
@@ -24,17 +24,21 @@ scroll: dvui.ScrollInfo = .{
    .horizontal = .auto,
 },
 native_scaling: bool = true,
-redraw_throttle_ms: u32 = 50,
-_visible_rect: ?Rect_i = null,
-_zoom: f32 = 1,
-_redraw_pending: bool = false,
-_last_redraw_time_ms: i64 = 0,
 cursor_document_point: ?Point2_f = null,
 draw_document: bool = true,
+show_render_stats: bool = true,
 /// Rect тулбара (из предыдущего кадра) для исключения кликов по нему из handleCanvasMouse.
 toolbar_rect_scale: ?dvui.RectScale = null,
 /// Rect панели свойств (из предыдущего кадра) для исключения кликов по нему из handleCanvasMouse.
 properties_rect_scale: ?dvui.RectScale = null,
+redraw_throttle_ms: u32 = 50,
+frame_index: u64 = 0,
+
+_zoom: f32 = 1,
+_rendering_quality: f32 = 100.0,
+_last_redraw_time_ms: i64 = 0, // Метка последней перерисовки чтобы ограничить частоту
+_visible_rect: ?Rect_i = null,
+_redraw_pending: bool = false,

 pub fn init(allocator: std.mem.Allocator, document: *Document, engine: RenderEngine) Canvas {
    return .{
@@ -56,9 +60,9 @@ pub fn deinit(self: *Canvas) void {
 fn redraw(self: *Canvas) !void {
    const full = self.getZoomedImageSize();

-    const vis: Rect_i = self._visible_rect orelse Rect_i{ .x = 0, .y = 0, .w = 0, .h = 0 };
+    const vis_full: Rect_i = self._visible_rect orelse Rect_i{ .x = 0, .y = 0, .w = 0, .h = 0 };

-    if (vis.w == 0 or vis.h == 0) {
+    if (vis_full.w == 0 or vis_full.h == 0) {
        if (self.texture) |tex| {
            dvui.Texture.destroyLater(tex);
            self.texture = null;
@@ -66,11 +70,42 @@ fn redraw(self: *Canvas) !void {
        return;
    }

-    const canvas_size: Size_i = .{ .w = full.w, .h = full.h };
+    // Качество рендеринга задаётся в процентах площади (1–100),
+    // при этом фактически уменьшаем ширину/высоту холста на корень из этой доли.
+    const quality_percent: f32 = self.getRenderingQuality();
+    const quality_area: f32 = quality_percent / 100.0;
+    const quality_side: f32 = std.math.sqrt(quality_area);
+    const scale: f32 = std.math.clamp(quality_side, 0.01, 1.0);
+
+    const canvas_size: Size_i = .{
+        .w = @max(@as(u32, 1), @as(u32, @intFromFloat(@as(f32, @floatFromInt(full.w)) * scale))),
+        .h = @max(@as(u32, 1), @as(u32, @intFromFloat(@as(f32, @floatFromInt(full.h)) * scale))),
+    };
+
+    var vis_scaled = Rect_i{
+        .x = @as(u32, @intFromFloat(@as(f32, @floatFromInt(vis_full.x)) * scale)),
+        .y = @as(u32, @intFromFloat(@as(f32, @floatFromInt(vis_full.y)) * scale)),
+        .w = @max(@as(u32, 1), @as(u32, @intFromFloat(@as(f32, @floatFromInt(vis_full.w)) * scale))),
+        .h = @max(@as(u32, 1), @as(u32, @intFromFloat(@as(f32, @floatFromInt(vis_full.h)) * scale))),
+    };
+
+    if (vis_scaled.x >= canvas_size.w or vis_scaled.y >= canvas_size.h) {
+        if (self.texture) |tex| {
+            dvui.Texture.destroyLater(tex);
+            self.texture = null;
+        }
+        return;
+    }
+
+    const max_vis_w: u32 = canvas_size.w - vis_scaled.x;
+    const max_vis_h: u32 = canvas_size.h - vis_scaled.y;
+    if (vis_scaled.w > max_vis_w) vis_scaled.w = max_vis_w;
+    if (vis_scaled.h > max_vis_h) vis_scaled.h = max_vis_h;
+
    const new_texture = if (self.draw_document)
-        self.render_engine.render(self.document, canvas_size, vis) catch null
+        self.render_engine.render(self.document, canvas_size, vis_scaled) catch null
    else
-        self.render_engine.example(canvas_size, vis) catch null;
+        self.render_engine.example(canvas_size, vis_scaled) catch null;

    if (new_texture) |tex| {
        if (self.texture) |old_tex| {
@@ -80,6 +115,8 @@ fn redraw(self: *Canvas) !void {
        self.texture = tex;
    }
    self._last_redraw_time_ms = std.time.milliTimestamp();
+    self.frame_index += 1;
+    self.redraw_throttle_ms = @max(1, @as(u32, @intCast(self.render_engine.getStats().render_time_ns / std.time.ns_per_ms / 3)));
 }

 pub fn exampleReset(self: *Canvas) !void {
@@ -88,7 +125,7 @@ pub fn exampleReset(self: *Canvas) !void {
 }

 pub fn addRandomShapes(self: *Canvas) !void {
-    try random_document.addRandomShapes(self.document, std.crypto.random);
+    try random_document.addRandomShapes(self.document, self.allocator, std.crypto.random);
    self.requestRedraw();
 }

@@ -110,6 +147,15 @@ pub fn getZoom(self: Canvas) f32 {
    return self._zoom;
 }

+pub fn setRenderingQuality(self: *Canvas, value: f32) void {
+    self._rendering_quality = std.math.clamp(value, 1.0, 100.0);
+    self.requestRedraw();
+}
+
+pub fn getRenderingQuality(self: Canvas) f32 {
+    return self._rendering_quality;
+}
+
 pub fn requestRedraw(self: *Canvas) void {
    self._redraw_pending = true;
 }
--- a/src/WindowContext.zig
+++ b/src/WindowContext.zig
@@ -16,15 +16,10 @@ pub const OpenDocument = struct {
    selected_object_id: ?u64 = null,

    pub fn init(allocator: std.mem.Allocator, self: *OpenDocument) void {
-        const default_size = basic_models.Size_f{ .w = 800, .h = 600 };
-        self.document = Document.init(allocator, default_size);
-        self.cpu_render = CpuRenderEngine.init(allocator, .Squares);
-        self.canvas = Canvas.init(
-            allocator,
-            &self.document,
-            (&self.cpu_render).renderEngine(),
-        );
-        self.selected_object_id = null;
+        initWithDocument(allocator, self, .init(.{
+            .w = 800,
+            .h = 600,
+        }));
    }

    pub fn initWithDocument(allocator: std.mem.Allocator, self: *OpenDocument, doc: Document) void {
@@ -38,24 +33,21 @@ pub const OpenDocument = struct {
        self.selected_object_id = null;
    }

-    pub fn deinit(self: *OpenDocument) void {
-        self.document.deinit();
+    pub fn deinit(self: *OpenDocument, allocator: std.mem.Allocator) void {
+        self.document.deinit(allocator);
        self.canvas.deinit();
    }
 };

 allocator: std.mem.Allocator,
-frame_index: u64,
 documents: std.ArrayList(*OpenDocument),
 active_document_index: ?usize,

 pub fn init(allocator: std.mem.Allocator) !WindowContext {
-    const frame_index: u64 = 0;
    const documents = std.ArrayList(*OpenDocument).empty;
    const active_document_index: ?usize = null;
    return .{
        .allocator = allocator,
-        .frame_index = frame_index,
        .documents = documents,
        .active_document_index = active_document_index,
    };
@@ -63,7 +55,7 @@ pub fn init(allocator: std.mem.Allocator) !WindowContext {

 pub fn deinit(self: *WindowContext) void {
    for (self.documents.items) |ptr| {
-        ptr.deinit();
+        ptr.deinit(self.allocator);
        self.allocator.destroy(ptr);
    }
    self.documents.deinit(self.allocator);
@@ -88,7 +80,7 @@ pub fn addDocument(self: *WindowContext, doc: Document) !void {
    const ptr = try self.allocator.create(OpenDocument);
    errdefer self.allocator.destroy(ptr);
    var doc_mut = doc;
-    errdefer doc_mut.deinit();
+    errdefer doc_mut.deinit(self.allocator);
    OpenDocument.initWithDocument(self.allocator, ptr, doc_mut);
    try self.documents.append(self.allocator, ptr);
    self.active_document_index = self.documents.items.len - 1;
@@ -103,7 +95,7 @@ pub fn setActiveDocument(self: *WindowContext, index: usize) void {
 pub fn closeDocument(self: *WindowContext, index: usize) void {
    if (index >= self.documents.items.len) return;
    const open_doc = self.documents.items[index];
-    open_doc.deinit();
+    open_doc.deinit(self.allocator);
    self.allocator.destroy(open_doc);
    _ = self.documents.orderedRemove(index);

--- a/src/icons.zig
+++ b/src/icons.zig
@@ -1,9 +1,8 @@
 const dvui = @import("dvui");

-pub const line = dvui.entypo.line_graph;
+pub const line = dvui.entypo.flow_line;
 pub const ellipse = dvui.entypo.circle;
-pub const arc = dvui.entypo.loop;
-pub const broken = dvui.entypo.flow_line;
+pub const broken = dvui.entypo.line_graph;
 pub const trash = dvui.entypo.trash;
 pub const cross = dvui.entypo.cross;
 pub const plus = dvui.entypo.plus;
--- a/src/main.zig
+++ b/src/main.zig
@@ -5,7 +5,10 @@ const WindowContext = @import("WindowContext.zig");
 const ui = @import("ui/frame.zig");

 pub fn main() !void {
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    // std.heap.GeneralPurposeAllocator was renamed to DebugAllocator recently.
+    var gpa: std.heap.DebugAllocator(.{}) = .init;
+    defer _ = gpa.deinit();
+
    const allocator = gpa.allocator();

    var backend = try SDLBackend.initWindow(.{
--- a/src/models/Document.zig
+++ b/src/models/Document.zig
@@ -7,71 +7,86 @@ pub const Object = @import("Object.zig");
 const shape = @import("shape/shape.zig");

 size: Size_f,
-allocator: std.mem.Allocator,
 objects: std.ArrayList(Object),
 next_object_id: u64,

-pub fn init(allocator: std.mem.Allocator, size: Size_f) Document {
+pub fn init(size: Size_f) Document {
    return .{
        .size = size,
-        .allocator = allocator,
        .objects = std.ArrayList(Object).empty,
        .next_object_id = 1,
    };
 }

-pub fn deinit(self: *Document) void {
-    for (self.objects.items) |*obj| obj.deinit(self.allocator);
-    self.objects.deinit(self.allocator);
+pub fn deinit(self: *Document, allocator: std.mem.Allocator) void {
+    for (self.objects.items) |*obj| obj.deinit(allocator);
+    self.objects.deinit(allocator);
 }

-pub fn addObject(self: *Document, template: Object) !void {
-    const obj = try template.clone(self.allocator, &self.next_object_id);
-    try self.objects.append(self.allocator, obj);
+pub fn clone(self: *const Document, allocator: std.mem.Allocator) !Document {
+    var objects_list = std.ArrayList(Object).empty;
+    errdefer {
+        for (objects_list.items) |*obj| obj.deinit(allocator);
+        objects_list.deinit(allocator);
+    }
+    var next_id = self.next_object_id;
+    for (self.objects.items) |obj| {
+        try objects_list.append(allocator, try obj.clone(allocator, &next_id));
+    }
+    return .{
+        .size = self.size,
+        .objects = objects_list,
+        .next_object_id = next_id,
+    };
+}
+
+pub fn addObject(self: *Document, allocator: std.mem.Allocator, template: Object) !void {
+    const obj = try template.clone(allocator, &self.next_object_id);
+    try self.objects.append(allocator, obj);
 }

 /// Добавляет объект в документ: как ребёнка родителя (если id найден), иначе в корень.
-pub fn addObjectUnderParentId(self: *Document, parent_id: ?u64, template: Object) !void {
+pub fn addObjectUnderParentId(self: *Document, allocator: std.mem.Allocator, parent_id: ?u64, template: Object) !void {
    if (parent_id) |id| {
        if (self.findObjectById(id)) |parent| {
-            try parent.addChild(self.allocator, template, &self.next_object_id);
+            try parent.addChild(allocator, template, &self.next_object_id);
            return;
        }
    }
-    try self.addObject(template);
+    try self.addObject(allocator, template);
 }

-pub fn addShape(self: *Document, parent: ?*Object, shape_kind: Object.ShapeKind) !void {
-    const obj = try shape.createObject(self.allocator, shape_kind);
+pub fn addShape(self: *Document, allocator: std.mem.Allocator, parent: ?*Object, shape_kind: Object.ShapeKind) !void {
+    const obj = try shape.createObject(allocator, shape_kind);
    if (parent) |p| {
-        try p.addChild(self.allocator, obj, &self.next_object_id);
+        try p.addChild(allocator, obj, &self.next_object_id);
    } else {
-        try self.addObject(obj);
+        try self.addObject(allocator, obj);
    }
 }

 /// Удаляет объект из документа (из корня или из детей родителя). Возвращает true, если объект был найден и удалён.
-pub fn removeObject(self: *Document, obj: *Object) bool {
+pub fn removeObject(self: *Document, allocator: std.mem.Allocator, obj: *Object) bool {
    for (self.objects.items, 0..) |*item, i| {
        if (item == obj) {
            var removed = self.objects.orderedRemove(i);
-            removed.deinit(self.allocator);
+            removed.deinit(allocator);
            return true;
        }
-        if (removeFromChildren(self.allocator, &item.children, obj)) return true;
+        if (removeFromChildren(allocator, &item.children, obj)) return true;
    }
    return false;
 }

 /// Удаляет объект по id. Возвращает true, если объект был найден и удалён.
-pub fn removeObjectById(self: *Document, obj_id: u64) bool {
+pub fn removeObjectById(self: *Document, allocator: std.mem.Allocator, obj_id: u64) bool {
    for (self.objects.items, 0..) |*item, i| {
        if (item.id == obj_id) {
            var removed = self.objects.orderedRemove(i);
-            removed.deinit(self.allocator);
+            removed.deinit(allocator);
            return true;
        }
-        if (removeFromChildrenById(self.allocator, &item.children, obj_id)) return true;
+        if (removeFromChildrenById(allocator, &item.children, obj_id)) return true;
    }
    return false;
 }
--- a/src/models/Object.zig
+++ b/src/models/Object.zig
@@ -6,7 +6,6 @@ const Object = @This();
 pub const ShapeKind = enum {
    line,
    ellipse,
-    arc,
    broken,
 };

@@ -34,17 +33,18 @@ shape: ShapeKind,
 properties: std.ArrayList(Property),
 children: std.ArrayList(Object),

-pub fn getProperty(self: Object, tag: std.meta.Tag(PropertyData)) ?*const PropertyData {
+pub fn getProperty(self: Object, comptime tag: std.meta.Tag(PropertyData)) ?@FieldType(PropertyData, @tagName(tag)) {
    for (self.properties.items) |*prop| {
-        if (std.meta.activeTag(prop.data) == tag) return &prop.data;
+        if (std.meta.activeTag(prop.data) == tag) return @field(prop.data, @tagName(tag));
    }
    return null;
 }

+/// Забирает владение Property
 pub fn setProperty(self: *Object, allocator: std.mem.Allocator, prop: Property) !void {
    for (self.properties.items, 0..) |*p, i| {
        if (std.meta.activeTag(p.data) == std.meta.activeTag(prop.data)) {
-            if (p.data == .points) p.data.points.deinit(allocator);
+            if (p.data == .points) allocator.free(p.data.points);
            self.properties.items[i] = prop;
            return;
        }
--- a/src/models/Property.zig
+++ b/src/models/Property.zig
@@ -15,9 +15,17 @@ pub const Data = union(enum) {

    size: Size_f,
    radii: Radii_f,
+    /// Процент дуги эллипса: 100 — полный эллипс, 50 — полуэллипс (0..100).
+    arc_percent: f32,
    end_point: Point2_f,

-    points: std.ArrayList(Point2_f),
+    /// Владеет памятью; при deinit/clone — free/duplicate.
+    points: []const Point2_f,
+    /// Замкнутый контур (для ломаной: отрезок последняя–первая точка + заливка).
+    closed: bool,
+
+    /// Включена ли заливка.
+    filled: bool,

    /// Цвет заливки, 0xRRGGBBAA.
    fill_rgba: u32,
@@ -32,7 +40,7 @@ pub const Property = struct {

    pub fn deinit(self: *Property, allocator: std.mem.Allocator) void {
        switch (self.data) {
-            .points => |*list| list.deinit(allocator),
+            .points => |slice| allocator.free(slice),
            else => {},
        }
        self.* = undefined;
@@ -40,9 +48,12 @@ pub const Property = struct {

    pub fn clone(self: Property, allocator: std.mem.Allocator) !Property {
        return switch (self.data) {
-            .points => |list| .{
+            .points => |slice| .{
                .data = .{
-                    .points = try list.clone(allocator),
+                    .points = blk: {
+                        const copy = try allocator.dupe(Point2_f, slice);
+                        break :blk copy;
+                    },
                },
            },
            else => .{ .data = self.data },
--- a/src/models/shape/arc.zig
+++ b/src/models/shape/arc.zig
@@ -1,23 +0,0 @@
-const std = @import("std");
-const Object = @import("../Object.zig");
-const PropertyData = @import("../Property.zig").Data;
-const Rect_f = @import("../basic_models.zig").Rect_f;
-const shape_mod = @import("shape.zig");
-
-/// Теги обязательных свойств (arc не реализован).
-pub fn getRequiredTags() []const std.meta.Tag(PropertyData) {
-    return &[_]std.meta.Tag(PropertyData){};
-}
-
-/// Добавляет свойства по умолчанию для дуги.
-pub fn appendDefaultShapeProperties(allocator: std.mem.Allocator, obj: *Object) !void {
-    _ = allocator;
-    _ = obj;
-    return error.ArcNotImplemented;
-}
-
-/// Локальные границы дуги (не реализовано).
-pub fn getLocalBounds(obj: *const Object) !Rect_f {
-    try shape_mod.ensure(obj, .arc);
-    return error.ArcNotImplemented;
-}
--- a/src/models/shape/broken.zig
+++ b/src/models/shape/broken.zig
@@ -6,46 +6,15 @@ const Point2_f = @import("../basic_models.zig").Point2_f;
 const Rect_f = @import("../basic_models.zig").Rect_f;
 const shape_mod = @import("shape.zig");

-/// Точки ломаной по умолчанию.
-pub const default_points = [_]Point2_f{
+/// Свойства фигуры по умолчанию (добавляются к общим). points — слайс на статический массив.
+pub const default_shape_properties_points = [_]Point2_f{
    .{ .x = 0, .y = 0 },
    .{ .x = 80, .y = 0 },
    .{ .x = 80, .y = 60 },
 };
-
-/// Теги обязательных свойств.
-pub fn getRequiredTags() []const std.meta.Tag(PropertyData) {
-    return &[_]std.meta.Tag(PropertyData){
-        .points,
-    };
-}
-
-/// Добавляет к объекту свойства по умолчанию для ломаной.
-pub fn appendDefaultShapeProperties(allocator: std.mem.Allocator, obj: *Object) !void {
-    var points = std.ArrayList(Point2_f).empty;
-    try points.appendSlice(allocator, &default_points);
-    try obj.properties.append(allocator, .{ .data = .{ .points = points } });
-}
-
-/// Локальные границы: AABB по точкам.
-pub fn getLocalBounds(obj: *const Object) !Rect_f {
-    try shape_mod.ensure(obj, .broken);
-    const p = obj.getProperty(.points).?;
-    if (p.points.items.len == 0) return error.EmptyPoints;
-    var min_x: f32 = p.points.items[0].x;
-    var max_x: f32 = min_x;
-    var min_y: f32 = p.points.items[0].y;
-    var max_y: f32 = min_y;
-    for (p.points.items[1..]) |pt| {
-        min_x = @min(min_x, pt.x);
-        max_x = @max(max_x, pt.x);
-        min_y = @min(min_y, pt.y);
-        max_y = @max(max_y, pt.y);
-    }
-    return .{
-        .x = min_x,
-        .y = min_y,
-        .w = max_x - min_x,
-        .h = max_y - min_y,
-    };
-}
+pub const default_shape_properties = [_]Property{
+    .{ .data = .{ .points = &default_shape_properties_points } },
+    .{ .data = .{ .closed = false } },
+    .{ .data = .{ .filled = true } },
+    .{ .data = .{ .fill_rgba = 0x000000FF } },
+};
--- a/src/models/shape/ellipse.zig
+++ b/src/models/shape/ellipse.zig
@@ -1,33 +1,14 @@
 const std = @import("std");
 const Object = @import("../Object.zig");
 const Property = @import("../Property.zig").Property;
-const PropertyData = @import("../Property.zig").Data;
 const Rect_f = @import("../basic_models.zig").Rect_f;
 const shape_mod = @import("shape.zig");

-/// Свойства фигуры по умолчанию.
+/// Свойства фигуры по умолчанию (добавляются к общим).
 pub const default_shape_properties = [_]Property{
    .{ .data = .{ .radii = .{ .x = 50, .y = 50 } } },
+    .{ .data = .{ .arc_percent = 100.0 } },
+    .{ .data = .{ .closed = true } },
+    .{ .data = .{ .filled = false } },
+    .{ .data = .{ .fill_rgba = 0x000000FF } },
 };
-
-/// Теги обязательных свойств.
-pub fn getRequiredTags() []const std.meta.Tag(PropertyData) {
-    return &([_]std.meta.Tag(PropertyData){std.meta.activeTag(default_shape_properties[0].data)});
-}
-
-/// Добавляет к объекту свойства по умолчанию для эллипса.
-pub fn appendDefaultShapeProperties(allocator: std.mem.Allocator, obj: *Object) !void {
-    for (default_shape_properties) |prop| try obj.properties.append(allocator, prop);
-}
-
-/// Локальные границы эллипса: [-radii.x, -radii.y] .. [radii.x, radii.y].
-pub fn getLocalBounds(obj: *const Object) !Rect_f {
-    try shape_mod.ensure(obj, .ellipse);
-    const r = obj.getProperty(.radii).?;
-    return .{
-        .x = -r.radii.x,
-        .y = -r.radii.y,
-        .w = 2 * r.radii.x,
-        .h = 2 * r.radii.y,
-    };
-}
--- a/src/models/shape/line.zig
+++ b/src/models/shape/line.zig
@@ -1,37 +1,10 @@
 const std = @import("std");
 const Object = @import("../Object.zig");
 const Property = @import("../Property.zig").Property;
-const PropertyData = @import("../Property.zig").Data;
 const Rect_f = @import("../basic_models.zig").Rect_f;
 const shape_mod = @import("shape.zig");

-/// Свойства фигуры по умолчанию.
+/// Свойства фигуры по умолчанию (добавляются к общим).
 pub const default_shape_properties = [_]Property{
    .{ .data = .{ .end_point = .{ .x = 100, .y = 200 } } },
 };
-
-/// Теги обязательных свойств.
-pub fn getRequiredTags() []const std.meta.Tag(PropertyData) {
-    return &([_]std.meta.Tag(PropertyData){std.meta.activeTag(default_shape_properties[0].data)});
-}
-
-/// Добавляет к объекту свойства по умолчанию для линии.
-pub fn appendDefaultShapeProperties(allocator: std.mem.Allocator, obj: *Object) !void {
-    for (default_shape_properties) |prop| try obj.properties.append(allocator, prop);
-}
-
-/// Локальные границы: от (0,0) до end_point.
-pub fn getLocalBounds(obj: *const Object) !Rect_f {
-    try shape_mod.ensure(obj, .line);
-    const ep = obj.getProperty(.end_point).?;
-    const min_x = @min(0, ep.end_point.x);
-    const max_x = @max(0, ep.end_point.x);
-    const min_y = @min(0, ep.end_point.y);
-    const max_y = @max(0, ep.end_point.y);
-    return .{
-        .x = min_x,
-        .y = min_y,
-        .w = max_x - min_x,
-        .h = max_y - min_y,
-    };
-}
--- a/src/models/shape/shape.zig
+++ b/src/models/shape/shape.zig
@@ -4,22 +4,36 @@ const Property = @import("../Property.zig").Property;
 const PropertyData = @import("../Property.zig").Data;
 const defaultCommonProperties = Object.defaultCommonProperties;
 const basic_models = @import("../basic_models.zig");
+const Point2_f = basic_models.Point2_f;
 const line = @import("line.zig");
 const ellipse = @import("ellipse.zig");
 const broken = @import("broken.zig");
-const arc = @import("arc.zig");
+pub const Rect = basic_models.Rect_f;

-pub const Rect = basic_models.Rectf;
+/// Добавляет к объекту список свойств фигуры. Для .points дублирует слайс (объект владеет).
+fn appendShapeProperties(allocator: std.mem.Allocator, obj: *Object, props: []const Property) !void {
+    for (props) |prop| {
+        if (prop.data == .points) {
+            const pts = prop.data.points;
+            const copy = try allocator.dupe(Point2_f, pts);
+            try obj.properties.append(allocator, .{ .data = .{ .points = copy } });
+        } else {
+            try obj.properties.append(allocator, prop);
+        }
+    }
+}

 /// Создаёт объект с дефолтными общими и фигурными свойствами.
 pub fn createObject(allocator: std.mem.Allocator, shape_kind: Object.ShapeKind) !Object {
    var obj = try createWithCommonProperties(allocator, shape_kind);
    errdefer obj.deinit(allocator);
    switch (shape_kind) {
-        .line => try line.appendDefaultShapeProperties(allocator, &obj),
-        .ellipse => try ellipse.appendDefaultShapeProperties(allocator, &obj),
-        .broken => try broken.appendDefaultShapeProperties(allocator, &obj),
-        .arc => try arc.appendDefaultShapeProperties(allocator, &obj),
+        .line => try appendShapeProperties(allocator, &obj, &line.default_shape_properties),
+        .ellipse => try appendShapeProperties(allocator, &obj, &ellipse.default_shape_properties),
+        .broken => {
+            try appendShapeProperties(allocator, &obj, &broken.default_shape_properties);
+            try obj.setProperty(allocator, .{ .data = .{ .fill_rgba = obj.getProperty(.stroke_rgba).? } });
+        },
    }
    return obj;
 }
@@ -35,62 +49,3 @@ fn createWithCommonProperties(allocator: std.mem.Allocator, shape_kind: Object.S
        .children = std.ArrayList(Object).empty,
    };
 }
-
-/// Проверяет тип объекта и наличие обязательных свойств.
-pub fn ensure(obj: *const Object, expected_kind: Object.ShapeKind) !void {
-    if (obj.shape != expected_kind) return error.WrongShapeKind;
-    const tags = requiredTagsFor(expected_kind);
-    for (tags) |tag| {
-        if (obj.getProperty(tag) == null) return error.MissingRequiredProperty;
-    }
-}
-
-fn requiredTagsFor(kind: Object.ShapeKind) []const std.meta.Tag(PropertyData) {
-    return switch (kind) {
-        .line => line.getRequiredTags(),
-        .ellipse => ellipse.getRequiredTags(),
-        .broken => broken.getRequiredTags(),
-        .arc => arc.getRequiredTags(),
-    };
-}
-
-/// Локальные границы (AABB).
-pub fn getLocalBounds(obj: *const Object) !Rect {
-    return switch (obj.shape) {
-        .line => line.getLocalBounds(obj),
-        .ellipse => ellipse.getLocalBounds(obj),
-        .broken => broken.getLocalBounds(obj),
-        .arc => arc.getLocalBounds(obj),
-    };
-}
-
-test "getLocalBounds" {
-    const shape = @This();
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    defer _ = gpa.deinit();
-    const allocator = gpa.allocator();
-
-    var line_obj = try shape.createObject(allocator, .line);
-    defer line_obj.deinit(allocator);
-    const line_bounds = try getLocalBounds(&line_obj);
-    try std.testing.expect(line_bounds.x == 0);
-    try std.testing.expect(line_bounds.y == 0);
-    try std.testing.expect(line_bounds.w == 100);
-    try std.testing.expect(line_bounds.h == 0);
-
-    var ellipse_obj = try shape.createObject(allocator, .ellipse);
-    defer ellipse_obj.deinit(allocator);
-    const ellipse_bounds = try getLocalBounds(&ellipse_obj);
-    try std.testing.expect(ellipse_bounds.x == -50);
-    try std.testing.expect(ellipse_bounds.y == -50);
-    try std.testing.expect(ellipse_bounds.w == 100);
-    try std.testing.expect(ellipse_bounds.h == 100);
-
-    var broken_obj = try shape.createObject(allocator, .broken);
-    defer broken_obj.deinit(allocator);
-    const broken_bounds = try getLocalBounds(&broken_obj);
-    try std.testing.expect(broken_bounds.x == 0);
-    try std.testing.expect(broken_bounds.y == 0);
-    try std.testing.expect(broken_bounds.w == 80);
-    try std.testing.expect(broken_bounds.h == 60);
-}
--- a/src/persistence/document_json.zig
+++ b/src/persistence/document_json.zig
@@ -1,365 +0,0 @@
-const std = @import("std");
-const Document = @import("../models/Document.zig");
-const Object = Document.Object;
-const Property = @import("../models/Property.zig").Property;
-const PropertyData = @import("../models/Property.zig").Data;
-const basic_models = @import("../models/basic_models.zig");
-const Point2_f = basic_models.Point2_f;
-const Size_f = basic_models.Size_f;
-const Scale2_f = basic_models.Scale2_f;
-const Radii_f = basic_models.Radii_f;
-
-pub const json_version: u32 = 1;
-const JsonError = std.json.Stringify.Error;
-
-pub fn saveToFile(doc: *const Document, path: []const u8) !void {
-    var file = try std.fs.cwd().createFile(path, .{ .truncate = true });
-    defer file.close();
-
-    var buffer: [4096]u8 = undefined;
-    var writer = file.writer(&buffer);
-    var jw: std.json.Stringify = .{
-        .writer = &writer.interface,
-        .options = .{ .whitespace = .indent_2 },
-    };
-
-    try writeDocument(&jw, doc);
-    try writer.interface.flush();
-}
-
-pub fn loadFromFile(allocator: std.mem.Allocator, path: []const u8) !Document {
-    var file = try std.fs.cwd().openFile(path, .{});
-    defer file.close();
-
-    const data = try file.readToEndAlloc(allocator, std.math.maxInt(usize));
-    defer allocator.free(data);
-
-    var parsed = try std.json.parseFromSlice(std.json.Value, allocator, data, .{ .parse_numbers = true });
-    defer parsed.deinit();
-
-    return try parseDocumentValue(allocator, parsed.value);
-}
-
-fn writeDocument(jw: *std.json.Stringify, doc: *const Document) JsonError!void {
-    try jw.beginObject();
-    try jw.objectField("version");
-    try jw.write(json_version);
-    try jw.objectField("size");
-    try writeSize(jw, doc.size);
-    try jw.objectField("next_object_id");
-    try jw.write(doc.next_object_id);
-    try jw.objectField("objects");
-    try writeObjectArray(jw, doc.objects.items);
-    try jw.endObject();
-}
-
-fn writeSize(jw: *std.json.Stringify, size: Size_f) JsonError!void {
-    try jw.beginObject();
-    try jw.objectField("w");
-    try jw.write(size.w);
-    try jw.objectField("h");
-    try jw.write(size.h);
-    try jw.endObject();
-}
-
-fn writePoint(jw: *std.json.Stringify, pt: Point2_f) JsonError!void {
-    try jw.beginObject();
-    try jw.objectField("x");
-    try jw.write(pt.x);
-    try jw.objectField("y");
-    try jw.write(pt.y);
-    try jw.endObject();
-}
-
-fn writeScale(jw: *std.json.Stringify, scale: Scale2_f) JsonError!void {
-    try jw.beginObject();
-    try jw.objectField("scale_x");
-    try jw.write(scale.scale_x);
-    try jw.objectField("scale_y");
-    try jw.write(scale.scale_y);
-    try jw.endObject();
-}
-
-fn writeRadii(jw: *std.json.Stringify, radii: Radii_f) JsonError!void {
-    try jw.beginObject();
-    try jw.objectField("x");
-    try jw.write(radii.x);
-    try jw.objectField("y");
-    try jw.write(radii.y);
-    try jw.endObject();
-}
-
-fn writeObjectArray(jw: *std.json.Stringify, objects: []const Object) JsonError!void {
-    try jw.beginArray();
-    for (objects) |obj| {
-        try writeObject(jw, obj);
-    }
-    try jw.endArray();
-}
-
-fn writeObject(jw: *std.json.Stringify, obj: Object) JsonError!void {
-    try jw.beginObject();
-    try jw.objectField("id");
-    try jw.write(obj.id);
-    try jw.objectField("shape");
-    try jw.write(@tagName(obj.shape));
-    try jw.objectField("properties");
-    try writeProperties(jw, obj.properties.items);
-    try jw.objectField("children");
-    try writeObjectArray(jw, obj.children.items);
-    try jw.endObject();
-}
-
-fn writeProperties(jw: *std.json.Stringify, props: []const Property) JsonError!void {
-    try jw.beginArray();
-    for (props) |prop| {
-        try writeProperty(jw, prop);
-    }
-    try jw.endArray();
-}
-
-fn writeProperty(jw: *std.json.Stringify, prop: Property) JsonError!void {
-    try jw.beginObject();
-    try jw.objectField("tag");
-    try jw.write(@tagName(prop.data));
-    try jw.objectField("value");
-    switch (prop.data) {
-        .position => |p| try writePoint(jw, p),
-        .angle => |v| try jw.write(v),
-        .scale => |s| try writeScale(jw, s),
-        .visible => |v| try jw.write(v),
-        .opacity => |v| try jw.write(v),
-        .locked => |v| try jw.write(v),
-        .size => |s| try writeSize(jw, s),
-        .radii => |r| try writeRadii(jw, r),
-        .end_point => |p| try writePoint(jw, p),
-        .points => |list| {
-            try jw.beginArray();
-            for (list.items) |pt| {
-                try writePoint(jw, pt);
-            }
-            try jw.endArray();
-        },
-        .fill_rgba => |v| try jw.write(v),
-        .stroke_rgba => |v| try jw.write(v),
-        .thickness => |v| try jw.write(v),
-    }
-    try jw.endObject();
-}
-
-fn parseDocumentValue(allocator: std.mem.Allocator, value: std.json.Value) !Document {
-    const obj = try expectObject(value);
-    const version_val = try getField(obj, "version");
-    const version = try valueToU32(version_val);
-    if (version != json_version) return error.UnsupportedVersion;
-
-    const size_val = try getField(obj, "size");
-    const size = try parseSize(size_val);
-
-    var document = Document{
-        .size = size,
-        .allocator = allocator,
-        .objects = std.ArrayList(Object).empty,
-        .next_object_id = 1,
-    };
-    errdefer document.deinit();
-
-    const objects_val = try getField(obj, "objects");
-    const objects_arr = try expectArray(objects_val);
-    for (objects_arr.items) |item| {
-        const obj_item = try parseObject(allocator, item);
-        try document.objects.append(allocator, obj_item);
-    }
-
-    if (obj.get("next_object_id")) |next_val| {
-        const next_id = try valueToU64(next_val);
-        document.next_object_id = next_id;
-    } else {
-        document.next_object_id = computeNextObjectId(document.objects.items);
-    }
-
-    return document;
-}
-
-fn parseObject(allocator: std.mem.Allocator, value: std.json.Value) !Object {
-    const obj = try expectObject(value);
-    const id = try valueToU64(try getField(obj, "id"));
-    const shape_str = try valueToString(try getField(obj, "shape"));
-    const shape = std.meta.stringToEnum(Object.ShapeKind, shape_str) orelse return error.InvalidJson;
-
-    var properties = std.ArrayList(Property).empty;
-    errdefer {
-        for (properties.items) |*p| p.deinit(allocator);
-        properties.deinit(allocator);
-    }
-    var children = std.ArrayList(Object).empty;
-    errdefer {
-        for (children.items) |*c| c.deinit(allocator);
-        children.deinit(allocator);
-    }
-
-    const props_val = try getField(obj, "properties");
-    const props_arr = try expectArray(props_val);
-    for (props_arr.items) |item| {
-        try properties.append(allocator, try parseProperty(allocator, item));
-    }
-
-    const children_val = try getField(obj, "children");
-    const children_arr = try expectArray(children_val);
-    for (children_arr.items) |item| {
-        try children.append(allocator, try parseObject(allocator, item));
-    }
-
-    return .{
-        .id = id,
-        .shape = shape,
-        .properties = properties,
-        .children = children,
-    };
-}
-
-fn parseProperty(allocator: std.mem.Allocator, value: std.json.Value) !Property {
-    const obj = try expectObject(value);
-    const tag = try valueToString(try getField(obj, "tag"));
-    const val = try getField(obj, "value");
-
-    const data: PropertyData = if (std.mem.eql(u8, tag, "position")) blk: {
-        break :blk .{ .position = try parsePoint(val) };
-    } else if (std.mem.eql(u8, tag, "angle")) blk: {
-        break :blk .{ .angle = try valueToF32(val) };
-    } else if (std.mem.eql(u8, tag, "scale")) blk: {
-        break :blk .{ .scale = try parseScale(val) };
-    } else if (std.mem.eql(u8, tag, "visible")) blk: {
-        break :blk .{ .visible = try valueToBool(val) };
-    } else if (std.mem.eql(u8, tag, "opacity")) blk: {
-        break :blk .{ .opacity = try valueToF32(val) };
-    } else if (std.mem.eql(u8, tag, "locked")) blk: {
-        break :blk .{ .locked = try valueToBool(val) };
-    } else if (std.mem.eql(u8, tag, "size")) blk: {
-        break :blk .{ .size = try parseSize(val) };
-    } else if (std.mem.eql(u8, tag, "radii")) blk: {
-        break :blk .{ .radii = try parseRadii(val) };
-    } else if (std.mem.eql(u8, tag, "end_point")) blk: {
-        break :blk .{ .end_point = try parsePoint(val) };
-    } else if (std.mem.eql(u8, tag, "points")) blk: {
-        const arr = try expectArray(val);
-        var list = std.ArrayList(Point2_f).empty;
-        errdefer list.deinit(allocator);
-        for (arr.items) |item| {
-            try list.append(allocator, try parsePoint(item));
-        }
-        break :blk .{ .points = list };
-    } else if (std.mem.eql(u8, tag, "fill_rgba")) blk: {
-        break :blk .{ .fill_rgba = try valueToU32(val) };
-    } else if (std.mem.eql(u8, tag, "stroke_rgba")) blk: {
-        break :blk .{ .stroke_rgba = try valueToU32(val) };
-    } else if (std.mem.eql(u8, tag, "thickness")) blk: {
-        break :blk .{ .thickness = try valueToF32(val) };
-    } else {
-        return error.InvalidJson;
-    };
-
-    return .{ .data = data };
-}
-
-fn parsePoint(value: std.json.Value) !Point2_f {
-    const obj = try expectObject(value);
-    const x = try valueToF32(try getField(obj, "x"));
-    const y = try valueToF32(try getField(obj, "y"));
-    return .{ .x = x, .y = y };
-}
-
-fn parseSize(value: std.json.Value) !Size_f {
-    const obj = try expectObject(value);
-    const w = try valueToF32(try getField(obj, "w"));
-    const h = try valueToF32(try getField(obj, "h"));
-    return .{ .w = w, .h = h };
-}
-
-fn parseScale(value: std.json.Value) !Scale2_f {
-    const obj = try expectObject(value);
-    const sx = try valueToF32(try getField(obj, "scale_x"));
-    const sy = try valueToF32(try getField(obj, "scale_y"));
-    return .{ .scale_x = sx, .scale_y = sy };
-}
-
-fn parseRadii(value: std.json.Value) !Radii_f {
-    const obj = try expectObject(value);
-    const x = try valueToF32(try getField(obj, "x"));
-    const y = try valueToF32(try getField(obj, "y"));
-    return .{ .x = x, .y = y };
-}
-
-fn expectObject(value: std.json.Value) !std.json.ObjectMap {
-    return switch (value) {
-        .object => |o| o,
-        else => error.InvalidJson,
-    };
-}
-
-fn expectArray(value: std.json.Value) !std.json.Array {
-    return switch (value) {
-        .array => |a| a,
-        else => error.InvalidJson,
-    };
-}
-
-fn getField(obj: std.json.ObjectMap, key: []const u8) !std.json.Value {
-    return obj.get(key) orelse error.InvalidJson;
-}
-
-fn valueToString(value: std.json.Value) ![]const u8 {
-    return switch (value) {
-        .string => |s| s,
-        else => error.InvalidJson,
-    };
-}
-
-fn valueToBool(value: std.json.Value) !bool {
-    return switch (value) {
-        .bool => |b| b,
-        else => error.InvalidJson,
-    };
-}
-
-fn valueToF32(value: std.json.Value) !f32 {
-    return switch (value) {
-        .float => |f| @floatCast(f),
-        .integer => |i| @floatFromInt(i),
-        else => error.InvalidJson,
-    };
-}
-
-fn valueToU32(value: std.json.Value) !u32 {
-    const v = switch (value) {
-        .integer => |i| i,
-        else => return error.InvalidJson,
-    };
-    if (v < 0 or v > std.math.maxInt(u32)) return error.InvalidJson;
-    return @intCast(v);
-}
-
-fn valueToU64(value: std.json.Value) !u64 {
-    const v = switch (value) {
-        .integer => |i| i,
-        else => return error.InvalidJson,
-    };
-    if (v < 0) return error.InvalidJson;
-    return @intCast(v);
-}
-
-fn computeNextObjectId(objects: []const Object) u64 {
-    var max_id: u64 = 0;
-    for (objects) |obj| {
-        max_id = @max(max_id, maxIdInObject(obj));
-    }
-    return max_id + 1;
-}
-
-fn maxIdInObject(obj: Object) u64 {
-    var max_id = obj.id;
-    for (obj.children.items) |child| {
-        max_id = @max(max_id, maxIdInObject(child));
-    }
-    return max_id;
-}
--- a/src/persistence/json_io.zig
+++ b/src/persistence/json_io.zig
@@ -0,0 +1,33 @@
+const std = @import("std");
+const Document = @import("../models/Document.zig");
+
+/// Сохраняет значение произвольного типа T в JSON-файл.
+pub fn saveToFile(comptime T: type, value: *const T, path: []const u8) !void {
+    var file = try std.fs.cwd().createFile(path, .{ .truncate = true });
+    defer file.close();
+
+    var buffer: [4096]u8 = undefined;
+    var writer = file.writer(&buffer);
+
+    try std.json.Stringify.value(value, .{ .whitespace = .indent_2 }, &writer.interface);
+
+    try writer.interface.flush();
+}
+
+/// Загружает значение типа T из JSON-файла.
+/// Для Document после разбора делается клон через allocator, т.к. парсер выделяет память
+/// из арены — при закрытии документа её нельзя освобождать нашим аллокатором.
+pub fn loadFromFile(comptime T: type, allocator: std.mem.Allocator, path: []const u8) !T {
+    var file = try std.fs.cwd().openFile(path, .{});
+    defer file.close();
+
+    const data = try file.readToEndAlloc(allocator, std.math.maxInt(usize));
+    defer allocator.free(data);
+
+    var parsed = try std.json.parseFromSlice(T, allocator, data, .{ .ignore_unknown_fields = true });
+    if (T == Document) {
+        defer parsed.deinit();
+        return try parsed.value.clone(allocator);
+    }
+    return parsed.value;
+}
--- a/src/random_document.zig
+++ b/src/random_document.zig
@@ -74,33 +74,35 @@ fn randomizeObjectProperties(allocator: std.mem.Allocator, doc_size: *const Size
            } });
        },
        .broken => {
-            var points = std.ArrayList(Point2_f).empty;
+            var list = std.ArrayList(Point2_f).empty;
+            defer list.deinit(allocator);
            const n = rng.intRangeLessThan(usize, 2, 9);
            var x: f32 = 0;
            var y: f32 = 0;
            for (0..n) |_| {
-                try points.append(allocator, .{ .x = x, .y = y });
+                try list.append(allocator, .{ .x = x, .y = y });
                x += randFloat(rng, -40, 80);
                y += randFloat(rng, -30, 60);
            }
-            try obj.setProperty(allocator, .{ .data = .{ .points = points } });
+            const slice = try allocator.dupe(Point2_f, list.items);
+            errdefer allocator.free(slice);
+            try obj.setProperty(allocator, .{ .data = .{ .points = slice } });
        },
-        .arc => {},
    }
 }

 /// Создаёт в документе случайные фигуры (line, ellipse, broken).
-pub fn addRandomShapes(doc: *Document, rng: std.Random) !void {
+pub fn addRandomShapes(doc: *Document, allocator: std.mem.Allocator, rng: std.Random) !void {
    const max_total: usize = 80;
    var total_count: usize = 0;
-    const allocator = doc.allocator;

    const n_root = rng.intRangeLessThan(usize, 6, 15);
    for (0..n_root) |_| {
        if (total_count >= max_total) break;
        var obj = try shape.createObject(allocator, randomShapeKind(rng));
+        defer obj.deinit(allocator);
        try randomizeObjectProperties(allocator, &doc.size, &obj, rng);
-        try doc.addObject(obj);
+        try doc.addObject(allocator, obj);
        total_count += 1;
    }

@@ -116,6 +118,7 @@ pub fn addRandomShapes(doc: *Document, rng: std.Random) !void {
        for (0..n_children) |_| {
            if (total_count >= max_total) break;
            var child = try shape.createObject(allocator, randomShapeKind(rng));
+            defer child.deinit(allocator);
            try randomizeObjectProperties(allocator, &doc.size, &child, rng);
            try obj.addChild(allocator, child, &doc.next_object_id);
            total_count += 1;
--- a/src/render/CpuRenderEngine.zig
+++ b/src/render/CpuRenderEngine.zig
@@ -5,6 +5,7 @@ const RenderEngine = @import("RenderEngine.zig").RenderEngine;
 const Document = @import("../models/Document.zig");
 const basic_models = @import("../models/basic_models.zig");
 const cpu_draw = @import("cpu/draw.zig");
+const RenderStats = @import("RenderStats.zig");
 const Size_i = basic_models.Size_i;
 const Rect_i = basic_models.Rect_i;
 const Allocator = std.mem.Allocator;
@@ -17,14 +18,18 @@ const Type = enum {
 };

 type: Type,
-_allocator: Allocator,
 gradient_start: Color.PMA = .{ .r = 0, .g = 0, .b = 0, .a = 255 },
 gradient_end: Color.PMA = .{ .r = 255, .g = 255, .b = 255, .a = 255 },
+_allocator: Allocator,
+_renderStats: RenderStats,

 pub fn init(allocator: Allocator, render_type: Type) CpuRenderEngine {
    return .{
        ._allocator = allocator,
        .type = render_type,
+        ._renderStats = .{
+            .render_time_ns = 0,
+        },
    };
 }

@@ -61,9 +66,7 @@ fn renderGradient(self: CpuRenderEngine, pixels: []Color.PMA, width: u32, height
    }
 }

-fn renderSquares(self: CpuRenderEngine, pixels: []Color.PMA, canvas_size: Size_i, visible_rect: Rect_i) void {
-    _ = self;
-
+fn renderSquares(pixels: []Color.PMA, canvas_size: Size_i, visible_rect: Rect_i) void {
    const colors = [_]Color.PMA{
        .{ .r = 255, .g = 0, .b = 0, .a = 255 },
        .{ .r = 255, .g = 165, .b = 0, .a = 255 },
@@ -164,10 +167,10 @@ pub fn example(self: CpuRenderEngine, canvas_size: Size_i, visible_rect: Rect_i)

    switch (self.type) {
        .Gradient => self.renderGradient(pixels, width, height, full_w, full_h, visible_rect),
-        .Squares => self.renderSquares(pixels, canvas_size, visible_rect),
+        .Squares => renderSquares(pixels, canvas_size, visible_rect),
    }

-    return try dvui.textureCreate(pixels, width, height, .nearest);
+    return try dvui.textureCreate(pixels, width, height, .nearest, .rgba_8_8_8_8);
 }

 pub fn renderEngine(self: *CpuRenderEngine) RenderEngine {
@@ -182,7 +185,13 @@ pub fn renderDocument(self: *CpuRenderEngine, document: *const Document, canvas_
    defer self._allocator.free(pixels);

    for (pixels) |*p| p.* = .{ .r = 255, .g = 255, .b = 255, .a = 255 };
+    var t = try std.time.Timer.start();
    try cpu_draw.drawDocument(pixels, width, height, visible_rect, document, canvas_size, self._allocator);
+    self._renderStats.render_time_ns = t.read();

-    return try dvui.textureCreate(pixels, width, height, .nearest);
+    return try dvui.textureCreate(pixels, width, height, .nearest, .rgba_8_8_8_8);
+}
+
+pub fn getStats(self: CpuRenderEngine) RenderStats {
+    return self._renderStats;
 }
--- a/src/render/RenderEngine.zig
+++ b/src/render/RenderEngine.zig
@@ -2,6 +2,7 @@ const dvui = @import("dvui");
 const CpuRenderEngine = @import("CpuRenderEngine.zig");
 const Document = @import("../models/Document.zig");
 const basic_models = @import("../models/basic_models.zig");
+const RenderStats = @import("RenderStats.zig");

 pub const RenderEngine = union(enum) {
    cpu: *CpuRenderEngine,
@@ -18,6 +19,12 @@ pub const RenderEngine = union(enum) {
        };
    }

+    pub fn getStats(self: RenderEngine) RenderStats {
+        return switch (self) {
+            .cpu => |cpu_r| cpu_r.getStats(),
+        };
+    }
+
    /// Растеризует документ в текстуру.
    pub fn render(self: RenderEngine, document: *const Document, canvas_size: basic_models.Size_i, visible_rect: basic_models.Rect_i) !?dvui.Texture {
        return switch (self) {
--- a/src/render/RenderStats.zig
+++ b/src/render/RenderStats.zig
@@ -0,0 +1,3 @@
+const RenderStats = @This();
+
+render_time_ns: u64, // Время рендера кадра в микросекундах
--- a/src/render/cpu/arc.zig
+++ b/src/render/cpu/arc.zig
@@ -1,8 +0,0 @@
-const Document = @import("../../models/Document.zig");
-const pipeline = @import("pipeline.zig");
-const DrawContext = pipeline.DrawContext;
-
-const Object = Document.Object;
-
-/// Дуга (не реализовано).
-pub fn draw(_: *DrawContext, _: *const Object) void {}
--- a/src/render/cpu/broken.zig
+++ b/src/render/cpu/broken.zig
@@ -7,19 +7,22 @@ const Color = @import("dvui").Color;

 const Object = Document.Object;
 const default_stroke: Color.PMA = .{ .r = 0, .g = 0, .b = 0, .a = 255 };
+const default_fill: Color.PMA = .{ .r = 0, .g = 0, .b = 0, .a = 0 };
 const default_thickness: f32 = 2.0;

-/// Ломаная по точкам, обводка stroke_rgba
+/// Ломаная по точкам, обводка stroke_rgba. При closed — отрезок последняя–первая точка и заливка fill_rgba.
 pub fn draw(
    ctx: *DrawContext,
    obj: *const Object,
    allocator: std.mem.Allocator,
 ) !void {
-    const p_prop = obj.getProperty(.points) orelse return;
-    const pts = p_prop.points.items;
+    const pts = obj.getProperty(.points) orelse return;
    if (pts.len < 2) return;
-    const stroke = if (obj.getProperty(.stroke_rgba)) |s| pipeline.rgbaToPma(s.stroke_rgba) else default_stroke;
-    const thickness = if (obj.getProperty(.thickness)) |t| t.thickness else default_thickness;
+    const stroke = if (obj.getProperty(.stroke_rgba)) |stroke_rgba| pipeline.rgbaToPma(stroke_rgba) else default_stroke;
+    const thickness = obj.getProperty(.thickness) orelse default_thickness;
+    const closed = obj.getProperty(.closed) orelse false;
+    const filled = obj.getProperty(.filled) orelse true;
+    const fill_color = if (obj.getProperty(.fill_rgba)) |fill_rgba| pipeline.rgbaToPma(fill_rgba) else default_fill;

    const buffer = try allocator.alloc(Color.PMA, ctx.buf_width * ctx.buf_height);
    @memset(buffer, .{ .r = 0, .g = 0, .b = 0, .a = 0 });
@@ -29,9 +32,23 @@ pub fn draw(
    copy_ctx.pixels = buffer;
    copy_ctx.replace_mode = true;

+    const do_fill = closed and filled;
+
+    if (do_fill) {
+        copy_ctx.startFill(allocator) catch return;
+    }
+
    var i: usize = 0;
    while (i + 1 < pts.len) : (i += 1) {
-        line.drawLine(&copy_ctx, pts[i].x, pts[i].y, pts[i + 1].x, pts[i + 1].y, stroke, thickness);
+        line.drawLine(&copy_ctx, pts[i].x, pts[i].y, pts[i + 1].x, pts[i + 1].y, stroke, thickness, true);
+    }
+    if (closed and pts.len >= 2) {
+        const last = pts.len - 1;
+        line.drawLine(&copy_ctx, pts[last].x, pts[last].y, pts[0].x, pts[0].y, stroke, thickness, true);
+    }
+
+    if (do_fill) {
+        copy_ctx.stopFill(allocator, fill_color);
    }

    ctx.compositeDrawerContext(&copy_ctx, copy_ctx.transform.opacity);
--- a/src/render/cpu/draw.zig
+++ b/src/render/cpu/draw.zig
@@ -4,7 +4,6 @@ const pipeline = @import("pipeline.zig");
 const line = @import("line.zig");
 const ellipse = @import("ellipse.zig");
 const broken = @import("broken.zig");
-const arc = @import("arc.zig");
 const basic_models = @import("../../models/basic_models.zig");
 const Rect_i = basic_models.Rect_i;
 const Size_i = basic_models.Size_i;
@@ -14,7 +13,7 @@ const DrawContext = pipeline.DrawContext;
 const Transform = pipeline.Transform;

 fn isVisible(obj: *const Object) bool {
-    return if (obj.getProperty(.visible)) |p| p.visible else true;
+    return obj.getProperty(.visible) orelse true;
 }

 fn drawObject(
@@ -30,9 +29,8 @@ fn drawObject(

    switch (obj.shape) {
        .line => line.draw(ctx, obj),
-        .ellipse => ellipse.draw(ctx, obj),
+        .ellipse => try ellipse.draw(ctx, obj, allocator),
        .broken => try broken.draw(ctx, obj, allocator),
-        .arc => arc.draw(ctx, obj),
    }

    for (obj.children.items) |*child| {
--- a/src/render/cpu/ellipse.zig
+++ b/src/render/cpu/ellipse.zig
@@ -1,23 +1,36 @@
 const std = @import("std");
+const std_math = std.math;
 const Document = @import("../../models/Document.zig");
 const pipeline = @import("pipeline.zig");
+const line = @import("line.zig");
 const DrawContext = pipeline.DrawContext;
 const Color = @import("dvui").Color;
+const basic_models = @import("../../models/basic_models.zig");
+const Point2_f = basic_models.Point2_f;

 const Object = Document.Object;
 const default_stroke: Color.PMA = .{ .r = 0, .g = 0, .b = 0, .a = 255 };
+const default_fill: Color.PMA = .{ .r = 0, .g = 0, .b = 0, .a = 0 };
 const default_thickness: f32 = 2.0;

-/// Эллипс с центром (0,0) и полуосями radii (обводка с учётом thickness).
-pub fn draw(ctx: *DrawContext, obj: *const Object) void {
-    const r_prop = obj.getProperty(.radii) orelse return;
-    const rx = r_prop.radii.x;
-    const ry = r_prop.radii.y;
+/// Эллипс с центром (0,0) и полуосями radii. Обводка — полоса расстояния до контура (чёткая линия, не круги).
+/// arc_percent: 100 — полный эллипс, иначе одна дуга; обход в коде от (0,ry) по квадрантам (визуально может казаться от низа против часовой из‑за экранной Y).
+/// Отрисовка в отдельный буфер и один composite, чтобы при alpha<255 пиксели не накладывались несколько раз.
+pub fn draw(ctx: *DrawContext, obj: *const Object, allocator: std.mem.Allocator) !void {
+    const radii = obj.getProperty(.radii) orelse return;
+    const rx = radii.x;
+    const ry = radii.y;
    if (rx <= 0 or ry <= 0) return;
-    const stroke = if (obj.getProperty(.stroke_rgba)) |s| pipeline.rgbaToPma(s.stroke_rgba) else default_stroke;
-    const thickness = if (obj.getProperty(.thickness)) |t| t.thickness else default_thickness;

-    // Полуширина обводки в нормализованных единицах (d = (x/rx)² + (y/ry)², граница при d=1).
+    const stroke = if (obj.getProperty(.stroke_rgba)) |stroke_rgba| pipeline.rgbaToPma(stroke_rgba) else default_stroke;
+    const thickness = if (obj.getProperty(.thickness)) |thickness| thickness else default_thickness;
+    const arc_percent = std_math.clamp(if (obj.getProperty(.arc_percent)) |arc_percent| arc_percent else 100.0, 0.0, 100.0);
+    const closed = obj.getProperty(.closed) orelse true;
+    const filled = obj.getProperty(.filled) orelse false;
+    const fill_color = if (obj.getProperty(.fill_rgba)) |fill_rgba| pipeline.rgbaToPma(fill_rgba) else default_fill;
+    const do_fill = filled and (closed or arc_percent >= 100.0);
+
+    const t = &ctx.transform;
    const min_r = @min(rx, ry);
    const half_norm = thickness / (2.0 * min_r);
    const inner = @max(0.0, 1.0 - half_norm);
@@ -25,19 +38,18 @@ pub fn draw(ctx: *DrawContext, obj: *const Object) void {
    const d_inner_sq = inner * inner;
    const d_outer_sq = outer * outer;

-    const corners = [_]struct { x: f32, y: f32 }{
-        .{ .x = -rx, .y = -ry },
-        .{ .x = rx, .y = -ry },
-        .{ .x = rx, .y = ry },
-        .{ .x = -rx, .y = ry },
+    const margin = 1.0 + half_norm;
+    const corners = [_]Point2_f{
+        .{ .x = -rx * margin, .y = -ry * margin },
+        .{ .x = rx * margin, .y = -ry * margin },
+        .{ .x = rx * margin, .y = ry * margin },
+        .{ .x = -rx * margin, .y = ry * margin },
    };
-    const w0 = ctx.localToWorld(corners[0].x, corners[0].y);
-    const b0 = ctx.worldToBufferF(w0.x, w0.y);
-    var min_bx: f32 = b0.x;
-    var min_by: f32 = b0.y;
-    var max_bx: f32 = b0.x;
-    var max_by: f32 = b0.y;
-    for (corners[1..]) |c| {
+    var min_bx: f32 = std_math.inf(f32);
+    var min_by: f32 = std_math.inf(f32);
+    var max_bx: f32 = -std_math.inf(f32);
+    var max_by: f32 = -std_math.inf(f32);
+    for (corners) |c| {
        const w = ctx.localToWorld(c.x, c.y);
        const b = ctx.worldToBufferF(w.x, w.y);
        min_bx = @min(min_bx, b.x);
@@ -47,50 +59,58 @@ pub fn draw(ctx: *DrawContext, obj: *const Object) void {
    }
    const buf_w: i32 = @intCast(ctx.buf_width);
    const buf_h: i32 = @intCast(ctx.buf_height);
-    const x0: i32 = @max(0, @as(i32, @intFromFloat(std.math.floor(min_bx))));
-    const y0: i32 = @max(0, @as(i32, @intFromFloat(std.math.floor(min_by))));
-    const x1: i32 = @min(buf_w, @as(i32, @intFromFloat(std.math.ceil(max_bx))) + 1);
-    const y1: i32 = @min(buf_h, @as(i32, @intFromFloat(std.math.ceil(max_by))) + 1);
+    const x0: i32 = @max(0, @as(i32, @intFromFloat(std_math.floor(min_bx))));
+    const y0: i32 = @max(0, @as(i32, @intFromFloat(std_math.floor(min_by))));
+    const x1: i32 = @min(buf_w, @as(i32, @intFromFloat(std_math.ceil(max_bx))) + 1);
+    const y1: i32 = @min(buf_h, @as(i32, @intFromFloat(std_math.ceil(max_by))) + 1);
+
+    const buffer = try allocator.alloc(Color.PMA, ctx.buf_width * ctx.buf_height);
+    @memset(buffer, .{ .r = 0, .g = 0, .b = 0, .a = 0 });
+    defer allocator.free(buffer);
+
+    var stroke_ctx = ctx.*;
+    stroke_ctx.pixels = buffer;
+    stroke_ctx.replace_mode = true;
+
+    if (do_fill) {
+        stroke_ctx.startFill(allocator) catch return;
+    }

-    // Один раз считаем аффин buffer -> local, чтобы в цикле не вызывать cos/sin и лишние функции.
-    const t = &ctx.transform;
-    const ctx_sx = if (ctx.scale_x != 0) ctx.scale_x else 1.0;
-    const ctx_sy = if (ctx.scale_y != 0) ctx.scale_y else 1.0;
-    const inv_ctx_sx = 1.0 / ctx_sx;
-    const inv_ctx_sy = 1.0 / ctx_sy;
-    const vx = @as(f32, @floatFromInt(ctx.visible_rect.x));
-    const vy = @as(f32, @floatFromInt(ctx.visible_rect.y));
-    const t_sx = if (t.scale.scale_x != 0) t.scale.scale_x else 1.0;
-    const t_sy = if (t.scale.scale_y != 0) t.scale.scale_y else 1.0;
-    const ca = std.math.cos(-t.angle);
-    const sa = std.math.sin(-t.angle);
-    const dx_off = vx * inv_ctx_sx - t.position.x;
-    const dy_off = vy * inv_ctx_sy - t.position.y;
-    const loc_x_off = (dx_off * ca - dy_off * sa) / t_sx;
-    const loc_y_off = (dx_off * sa + dy_off * ca) / t_sy;
-    const m00 = inv_ctx_sx * ca / t_sx;
-    const m01 = -inv_ctx_sy * sa / t_sx;
-    const m10 = inv_ctx_sx * sa / t_sy;
-    const m11 = inv_ctx_sy * ca / t_sy;
    const inv_rx = 1.0 / rx;
    const inv_ry = 1.0 / ry;
+    const arc_len = 2.0 * std_math.pi * arc_percent / 100.0;

    var by: i32 = y0;
    while (by < y1) : (by += 1) {
        const buf_y = @as(f32, @floatFromInt(by)) + 0.5;
-        const row_loc_x_off = buf_y * m01 + loc_x_off;
-        const row_loc_y_off = buf_y * m11 + loc_y_off;
        var bx: i32 = x0;
        while (bx < x1) : (bx += 1) {
            const buf_x = @as(f32, @floatFromInt(bx)) + 0.5;
-            const loc_x = buf_x * m00 + row_loc_x_off;
-            const loc_y = buf_x * m10 + row_loc_y_off;
-            const nx = loc_x * inv_rx;
-            const ny = loc_y * inv_ry;
+            const w = stroke_ctx.bufferToWorld(buf_x, buf_y);
+            const loc = stroke_ctx.worldToLocal(w.x, w.y);
+            const nx = loc.x * inv_rx;
+            const ny = loc.y * inv_ry;
            const d = nx * nx + ny * ny;
-            if (d >= d_inner_sq and d <= d_outer_sq) {
-                ctx.blendPixelAtBuffer(@intCast(bx), @intCast(by), stroke);
+            if (d < d_inner_sq or d > d_outer_sq) continue;
+            if (arc_percent < 100.0) {
+                var diff = std_math.pi / 2.0 - std_math.atan2(ny, nx);
+                if (diff < 0) diff += 2.0 * std_math.pi;
+                if (diff > arc_len) continue;
+            }
+            stroke_ctx.blendPixelAtBuffer(bx, by, stroke);
        }
    }
+
+    if (closed and arc_percent < 100.0) {
+        const end_x = rx * std_math.sin(arc_len);
+        const end_y = ry * std_math.cos(arc_len);
+        line.drawLine(&stroke_ctx, 0, 0, 0, ry, stroke, thickness, false);
+        line.drawLine(&stroke_ctx, 0, 0, end_x, end_y, stroke, thickness, false);
    }
+
+    if (do_fill) {
+        stroke_ctx.stopFill(allocator, fill_color);
+    }
+
+    ctx.compositeDrawerContext(&stroke_ctx, t.opacity);
 }
--- a/src/render/cpu/line.zig
+++ b/src/render/cpu/line.zig
@@ -12,16 +12,17 @@ const default_thickness: f32 = 2.0;

 /// Линия от (0,0) до end_point.
 pub fn draw(ctx: *DrawContext, obj: *const Object) void {
-    const ep_prop = obj.getProperty(.end_point) orelse return;
-    const end_x = ep_prop.end_point.x;
-    const end_y = ep_prop.end_point.y;
-    const stroke = if (obj.getProperty(.stroke_rgba)) |s| pipeline.rgbaToPma(s.stroke_rgba) else default_stroke;
-    const thickness = if (obj.getProperty(.thickness)) |t| t.thickness else default_thickness;
-    drawLine(ctx, 0, 0, end_x, end_y, stroke, thickness);
+    const end_point = obj.getProperty(.end_point) orelse return;
+    const end_x = end_point.x;
+    const end_y = end_point.y;
+    const stroke = if (obj.getProperty(.stroke_rgba)) |stroke_rgba| pipeline.rgbaToPma(stroke_rgba) else default_stroke;
+    const thickness = obj.getProperty(.thickness) orelse default_thickness;
+    drawLine(ctx, 0, 0, end_x, end_y, stroke, thickness, false);
 }

 /// Рисует отрезок по локальным концам (перевод в буфер внутри).
-pub fn drawLine(ctx: *DrawContext, x0: f32, y0: f32, x1: f32, y1: f32, color: Color.PMA, thickness: f32) void {
+/// draw_when_outside: если true, участки линии за экраном тоже рисуются (толщиной 1 px); в буфере — обычная толщина.
+pub fn drawLine(ctx: *DrawContext, x0: f32, y0: f32, x1: f32, y1: f32, color: Color.PMA, thickness: f32, draw_when_outside: bool) void {
    const w0 = ctx.localToWorld(x0, y0);
    const w1 = ctx.localToWorld(x1, y1);
    const b0 = ctx.worldToBuffer(w0.x, w0.y);
@@ -30,7 +31,7 @@ pub fn drawLine(ctx: *DrawContext, x0: f32, y0: f32, x1: f32, y1: f32, color: Co
    const scale = @sqrt(t.scale.scale_x * ctx.scale_x * t.scale.scale_y * ctx.scale_y);
    const thickness_px: u32 = @as(u32, @intFromFloat(std.math.round(thickness * scale)));
    if (thickness_px > 0)
-        drawLineInBuffer(ctx, b0.x, b0.y, b1.x, b1.y, color, thickness_px);
+        drawLineInBuffer(ctx, b0.x, b0.y, b1.x, b1.y, color, thickness_px, draw_when_outside);
 }

 inline fn clip(p: f32, q: f32, t0: *f32, t1: *f32) bool {
@@ -115,7 +116,7 @@ fn clipLineToBuffer(ctx: *DrawContext, a: *Point2_i, b: *Point2_i, thickness: i3
    return true;
 }

-fn drawLineInBuffer(ctx: *DrawContext, bx0: i32, by0: i32, bx1: i32, by1: i32, color: Color.PMA, thickness_px: u32) void {
+fn drawLineInBuffer(ctx: *DrawContext, bx0: i32, by0: i32, bx1: i32, by1: i32, color: Color.PMA, thickness_px: u32, draw_when_outside: bool) void {
    // Коррекция толщины в зависимости от угла линии.
    var thickness_corrected: u32 = thickness_px;
    var use_vertical: bool = undefined;
@@ -137,12 +138,15 @@ fn drawLineInBuffer(ctx: *DrawContext, bx0: i32, by0: i32, bx1: i32, by1: i32, c
        thickness_corrected = @max(@as(u32, 1), @as(u32, @intFromFloat(std.math.round(corrected_f))));
    }
    const half_thickness: i32 = @intCast(thickness_corrected / 2);
+    const thickness_corrected_i: i32 = @as(i32, @intCast(thickness_corrected));

    var p0 = Point2_i{ .x = bx0, .y = by0 };
    var p1 = Point2_i{ .x = bx1, .y = by1 };

-    // Отсечение отрезка буфером. Если он целиком вне — рисовать нечего.
+    // Отсечение только когда не рисуем вне viewport: иначе линия идёт целиком, толщина 1 px снаружи.
+    if (!draw_when_outside) {
        if (!clipLineToBuffer(ctx, &p0, &p1, @as(i32, @intCast(thickness_corrected)))) return;
+    }

    var x0 = p0.x;
    var y0 = p0.y;
@@ -156,15 +160,20 @@ fn drawLineInBuffer(ctx: *DrawContext, bx0: i32, by0: i32, bx1: i32, by1: i32, c
    const sy: i32 = if (y0 < ey) 1 else -1;

    var err: i32 = dx + dy;
+    const buf_w_i: i32 = @intCast(ctx.buf_width);
+    const buf_h_i: i32 = @intCast(ctx.buf_height);

    while (true) {
-        var thick: i32 = -half_thickness;
-        while (thick <= half_thickness) {
+        // Внутри viewport — полная толщина; снаружи при draw_when_outside — только 1 пиксель.
+        const in_viewport = x0 >= -thickness_corrected_i and x0 < buf_w_i + thickness_corrected_i and y0 >= -thickness_corrected_i and y0 < buf_h_i + thickness_corrected_i;
+        const effective_half: i32 = if (draw_when_outside and !in_viewport) 0 else half_thickness;
+
+        var thick: i32 = -effective_half;
+        while (thick <= effective_half) {
            const x = if (use_vertical) x0 + thick else x0;
            const y = if (use_vertical) y0 else y0 + thick;
-            if (x >= 0 and y >= 0) {
-                ctx.blendPixelAtBuffer(@intCast(x), @intCast(y), color);
-            }
+            ctx.blendPixelAtBuffer(x, y, color);
+
            thick += 1;
        }

--- a/src/render/cpu/pipeline.zig
+++ b/src/render/cpu/pipeline.zig
@@ -16,10 +16,10 @@ pub const Transform = struct {
    opacity: f32 = 1.0,

    pub fn init(obj: *const Document.Object) Transform {
-        const pos = if (obj.getProperty(.position)) |p| p.position else Point2_f{ .x = 0, .y = 0 };
-        const angle = if (obj.getProperty(.angle)) |p| p.angle else 0;
-        const scale = if (obj.getProperty(.scale)) |p| p.scale else Scale2_f{ .scale_x = 1, .scale_y = 1 };
-        const opacity = if (obj.getProperty(.opacity)) |p| p.opacity else 1.0;
+        const pos = obj.getProperty(.position) orelse Point2_f{ .x = 0, .y = 0 };
+        const angle = obj.getProperty(.angle) orelse 0;
+        const scale = obj.getProperty(.scale) orelse Scale2_f{ .scale_x = 1, .scale_y = 1 };
+        const opacity = obj.getProperty(.opacity) orelse 1.0;
        return .{
            .position = pos,
            .angle = angle,
@@ -75,6 +75,7 @@ pub const DrawContext = struct {
    transform: Transform = .{},
    /// Если true, blendPixelAtBuffer перезаписывает пиксель без бленда
    replace_mode: bool = false,
+    _fill_canvas: ?*FillCanvas = null,

    pub fn setTransform(self: *DrawContext, t: Transform) void {
        self.transform = t;
@@ -132,8 +133,13 @@ pub const DrawContext = struct {
    }

    /// Смешивает цвет в пикселе буфера с учётом opacity трансформа. В replace_mode просто перезаписывает пиксель.
-    pub fn blendPixelAtBuffer(self: *DrawContext, bx: u32, by: u32, color: Color.PMA) void {
-        if (bx >= self.buf_width or by >= self.buf_height) return;
+    /// Если активен fill canvas, каждый записанный пиксель помечается как граница для заливки.
+    pub fn blendPixelAtBuffer(self: *DrawContext, bx_i32: i32, by_i32: i32, color: Color.PMA) void {
+        if (self._fill_canvas) |fc| fc.setBorder(bx_i32, by_i32);
+
+        if (bx_i32 < 0 or by_i32 < 0 or bx_i32 >= self.buf_width or by_i32 >= self.buf_height) return;
+        const bx: u32 = @intCast(bx_i32);
+        const by: u32 = @intCast(by_i32);
        const idx = by * self.buf_width + bx;
        const dst = &self.pixels[idx];
        if (self.replace_mode) {
@@ -181,7 +187,24 @@ pub const DrawContext = struct {
        const vw = @as(i32, @intCast(self.visible_rect.w));
        const vh = @as(i32, @intCast(self.visible_rect.h));
        if (bx < 0 or bx >= vw or by < 0 or by >= vh) return;
-        self.blendPixelAtBuffer(@intCast(bx), @intCast(by), color);
+        self.blendPixelAtBuffer(bx, by, color);
+    }
+
+    /// Начинает сбор границ для заливки: создаёт FillCanvas и при последующих вызовах blendPixelAtBuffer помечает пиксели как границу.
+    pub fn startFill(self: *DrawContext, allocator: std.mem.Allocator) !void {
+        const fc = try FillCanvas.init(allocator, self.buf_width, self.buf_height);
+        const ptr = try allocator.create(FillCanvas);
+        ptr.* = fc;
+        self._fill_canvas = ptr;
+    }
+
+    /// Рисует заливку по собранным границам цветом color, освобождает FillCanvas и сбрасывает режим.
+    pub fn stopFill(self: *DrawContext, allocator: std.mem.Allocator, color: Color.PMA) void {
+        const fc = self._fill_canvas orelse return;
+        self._fill_canvas = null;
+        fc.fillColor(self, allocator, color);
+        fc.deinit();
+        allocator.destroy(fc);
    }
 };

@@ -200,3 +223,127 @@ pub fn rgbaToPma(rgba: u32) Color.PMA {
        .a = a,
    };
 }
+
+/// Контекст для заполнения фигур цветом. Границы хранятся в set — по x и y можно добавлять произвольные точки.
+const FillCanvas = struct {
+    /// Множество пикселей границы (x, y) — без ограничения по размеру буфера.
+    border_set: std.AutoHashMap(Point2_i, void),
+    buf_width: u32,
+    buf_height: u32,
+
+    pub fn init(allocator: std.mem.Allocator, width: u32, height: u32) !FillCanvas {
+        const border_set = std.AutoHashMap(Point2_i, void).init(allocator);
+        return .{
+            .border_set = border_set,
+            .buf_width = width,
+            .buf_height = height,
+        };
+    }
+
+    pub fn deinit(self: *FillCanvas) void {
+        self.border_set.deinit();
+    }
+
+    /// Добавляет точку границы; координаты x, y могут быть любыми (условно бесконечное поле).
+    pub fn setBorder(self: *FillCanvas, x: i32, y: i32) void {
+        self.border_set.put(.{ .x = x, .y = y }, {}) catch {};
+    }
+
+    /// Заливка четырёхсвязным стековым алгоритмом от первой найденной внутренней точки.
+    pub fn fillColor(self: *FillCanvas, draw_ctx: *DrawContext, allocator: std.mem.Allocator, color: Color.PMA) void {
+        const n = self.border_set.count();
+        if (n == 0) return;
+
+        const buf_w_i: i32 = @intCast(self.buf_width);
+        const buf_h_i: i32 = @intCast(self.buf_height);
+
+        // Ключи один раз по (y, x) — по строкам x уже будут отсортированы.
+        var keys_buf = std.ArrayList(Point2_i).empty;
+        defer keys_buf.deinit(allocator);
+        keys_buf.ensureTotalCapacity(allocator, n) catch return;
+        var iter = self.border_set.keyIterator();
+        while (iter.next()) |k| {
+            keys_buf.appendAssumeCapacity(k.*);
+        }
+        std.mem.sort(Point2_i, keys_buf.items, {}, struct {
+            fn lessThan(_: void, a: Point2_i, b: Point2_i) bool {
+                if (a.y != b.y) return a.y < b.y;
+                return a.x < b.x;
+            }
+        }.lessThan);
+
+        // Семена: по строкам находим сегменты (пары x), пересекаем с окном буфера, берём середину сегмента.
+        var seeds = findFillSeeds(keys_buf.items, buf_w_i, buf_h_i, allocator) catch return;
+        defer seeds.deinit(allocator);
+
+        var stack = std.ArrayList(Point2_i).empty;
+        defer stack.deinit(allocator);
+        var filled = std.AutoHashMap(Point2_i, void).init(allocator);
+        defer filled.deinit();
+
+        for (seeds.items) |s| {
+            if (self.border_set.contains(s)) continue;
+            if (filled.contains(s)) continue;
+            stack.clearRetainingCapacity();
+            stack.append(allocator, s) catch return;
+            while (stack.pop()) |cell| {
+                if (self.border_set.contains(cell)) continue;
+                const gop = filled.getOrPut(cell) catch return;
+                if (gop.found_existing) continue;
+
+                if (cell.x >= 0 and cell.x < buf_w_i and cell.y >= 0 and cell.y < buf_h_i) {
+                    draw_ctx.blendPixelAtBuffer(cell.x, cell.y, color);
+                }
+                if (cell.x > 0) stack.append(allocator, .{ .x = cell.x - 1, .y = cell.y }) catch return;
+                if (cell.x < buf_w_i - 1) stack.append(allocator, .{ .x = cell.x + 1, .y = cell.y }) catch return;
+                if (cell.y > 0) stack.append(allocator, .{ .x = cell.x, .y = cell.y - 1 }) catch return;
+                if (cell.y < buf_h_i - 1) stack.append(allocator, .{ .x = cell.x, .y = cell.y + 1 }) catch return;
+            }
+        }
+    }
+
+    /// По строкам: рёбра (подряд идущие x) → сегменты между ними. Семена — середины чётных сегментов (при чётном числе границ).
+    fn findFillSeeds(
+        keys: []const Point2_i,
+        buf_w_i: i32,
+        buf_h_i: i32,
+        allocator: std.mem.Allocator,
+    ) !std.ArrayList(Point2_i) {
+        var list = std.ArrayList(Point2_i).empty;
+        errdefer list.deinit(allocator);
+        var segments = std.ArrayList(struct { left: i32, right: i32 }).empty;
+        defer segments.deinit(allocator);
+
+        var i: usize = 0;
+        while (i < keys.len) {
+            const y = keys[i].y;
+            const row_start = i;
+            while (i < keys.len and keys[i].y == y) : (i += 1) {}
+            const row = keys[row_start..i];
+            if (row.len < 2 or y < 0 or y >= buf_h_i) continue;
+
+            segments.clearRetainingCapacity();
+            var run_end_x: i32 = row[0].x;
+            for (row[1..]) |p| {
+                if (p.x != run_end_x + 1) {
+                    try segments.append(allocator, .{ .left = run_end_x + 1, .right = p.x - 1 });
+                    run_end_x = p.x;
+                } else {
+                    run_end_x = p.x;
+                }
+            }
+            // Семена только при чётном числе границ
+            if ((segments.items.len + 1) % 2 != 0) continue;
+
+            for (segments.items, 0..) |seg, gi| {
+                if (gi % 2 != 0 or seg.left > seg.right) continue;
+                const left = @max(seg.left, 0);
+                const right = @min(seg.right, buf_w_i - 1);
+                if (left <= right) {
+                    try list.append(allocator, .{ .x = left + @divTrunc(right - left, 2), .y = y });
+                }
+            }
+        }
+        return list;
+    }
+};
--- a/src/toolbar/Tool.zig
+++ b/src/toolbar/Tool.zig
@@ -13,8 +13,8 @@ pub const ToolContext = struct {
    pub fn addObject(self: *const ToolContext, template: Document.Object) !void {
        var obj = template;
        const local_pos = self.computeLocalPosition();
-        try obj.setProperty(self.canvas.document.allocator, .{ .data = .{ .position = local_pos } });
-        try self.canvas.document.addObjectUnderParentId(self.selected_object_id, obj);
+        try obj.setProperty(self.canvas.allocator, .{ .data = .{ .position = local_pos } });
+        try self.canvas.document.addObjectUnderParentId(self.canvas.allocator, self.selected_object_id, obj);
        self.canvas.requestRedraw();
    }

--- a/src/toolbar/tools.zig
+++ b/src/toolbar/tools.zig
@@ -1,7 +1,6 @@
 const Toolbar = @import("Toolbar.zig");
 const line = @import("tools/line.zig");
 const ellipse = @import("tools/ellipse.zig");
-const arc = @import("tools/arc.zig");
 const broken = @import("tools/broken.zig");
 const icons = @import("../icons.zig");

@@ -16,11 +15,6 @@ pub const default_tools = [_]Toolbar.ToolDescriptor{
        .icon_tvg = icons.ellipse,
        .implementation = &ellipse.tool,
    },
-    .{
-        .name = "Arc",
-        .icon_tvg = icons.arc,
-        .implementation = &arc.tool,
-    },
    .{
        .name = "Broken line",
        .icon_tvg = icons.broken,
--- a/src/toolbar/tools/arc.zig
+++ b/src/toolbar/tools/arc.zig
@@ -1,10 +0,0 @@
-const Tool = @import("../Tool.zig");
-const shape = @import("../../models/shape/shape.zig");
-
-fn onCanvasClick(ctx: *const Tool.ToolContext) !void {
-    const canvas = ctx.canvas;
-    var obj = shape.createObject(canvas.document.allocator, .arc) catch return;
-    defer obj.deinit(canvas.allocator);
-    try ctx.addObject(obj);
-}
-pub const tool = Tool.Tool{ .onCanvasClick = onCanvasClick };
--- a/src/toolbar/tools/broken.zig
+++ b/src/toolbar/tools/broken.zig
@@ -3,7 +3,7 @@ const shape = @import("../../models/shape/shape.zig");

 fn onCanvasClick(ctx: *const Tool.ToolContext) !void {
    const canvas = ctx.canvas;
-    var obj = shape.createObject(canvas.document.allocator, .broken) catch return;
+    var obj = shape.createObject(canvas.allocator, .broken) catch return;
    defer obj.deinit(canvas.allocator);
    try ctx.addObject(obj);
 }
--- a/src/toolbar/tools/ellipse.zig
+++ b/src/toolbar/tools/ellipse.zig
@@ -3,7 +3,7 @@ const shape = @import("../../models/shape/shape.zig");

 fn onCanvasClick(ctx: *const Tool.ToolContext) !void {
    const canvas = ctx.canvas;
-    var obj = shape.createObject(canvas.document.allocator, .ellipse) catch return;
+    var obj = shape.createObject(canvas.allocator, .ellipse) catch return;
    defer obj.deinit(canvas.allocator);
    try ctx.addObject(obj);
 }
--- a/src/toolbar/tools/line.zig
+++ b/src/toolbar/tools/line.zig
@@ -5,7 +5,7 @@ const shape = @import("../../models/shape/shape.zig");

 fn onCanvasClick(ctx: *const Tool.ToolContext) !void {
    const canvas = ctx.canvas;
-    var obj = shape.createObject(canvas.document.allocator, .line) catch return;
+    var obj = shape.createObject(canvas.allocator, .line) catch return;
    defer obj.deinit(canvas.allocator);
    try ctx.addObject(obj);
 }
--- a/src/ui/canvas_view.zig
+++ b/src/ui/canvas_view.zig
@@ -6,7 +6,10 @@ const Document = @import("../models/Document.zig");
 const Property = @import("../models/Property.zig").Property;
 const PropertyData = @import("../models/Property.zig").Data;
 const Rect_i = @import("../models/basic_models.zig").Rect_i;
+const Point2_f = @import("../models/basic_models.zig").Point2_f;
 const Tool = @import("../toolbar/Tool.zig");
+const RenderStats = @import("../render/RenderStats.zig");
+const icons = @import("../icons.zig");

 pub fn canvasView(canvas: *Canvas, selected_object_id: ?u64, content_rect_scale: dvui.RectScale) void {
    var textured = dvui_ext.texturedBox(content_rect_scale, dvui.Rect.all(20));
@@ -14,14 +17,15 @@ pub fn canvasView(canvas: *Canvas, selected_object_id: ?u64, content_rect_scale:
        var overlay = dvui.overlay(@src(), .{ .expand = .both });
        {
            const overlay_parent = dvui.parentGet();
-            var scroll = dvui.scrollArea(
-                @src(),
-                .{
+            const init_options: dvui.ScrollAreaWidget.InitOpts = .{
                .scroll_info = &canvas.scroll,
                .vertical_bar = .auto,
                .horizontal_bar = .auto,
                .process_events_after = false,
-                },
+            };
+            var scroll = dvui.scrollArea(
+                @src(),
+                init_options,
                .{
                    .expand = .both,
                    .background = false,
@@ -36,23 +40,27 @@ pub fn canvasView(canvas: *Canvas, selected_object_id: ?u64, content_rect_scale:
            const scroll_parent = dvui.parentGet();
            dvui.parentSet(overlay_parent);

+            const vbar = scroll.vbar;
+            const hbar = scroll.hbar;
+            if (vbar != null) {
+
+                // std.debug.print("{any}", .{vbar.?.data()});
+            }
+            if (hbar != null) {
+                // std.debug.print("{any}", .{hbar.?.data()});
+            }
+
            // Тулбар поверх scroll
            var toolbar_box = dvui.box(
                @src(),
                .{ .dir = .horizontal },
-                .{
-                    .expand = .none,
-                    .background = false,
-                    .gravity_x = 0.0,
-                    .gravity_y = 0.0,
-                    .margin = dvui.Rect{ .x = 16, .y = 16 },
-                },
+                .{},
            );
            {
                drawToolbar(canvas);
-            }
                // Сохраняем rect тулбара для следующего кадра — в handleCanvasMouse исключаем из него клики
                canvas.toolbar_rect_scale = toolbar_box.data().contentRectScale();
+            }
            toolbar_box.deinit();

            // Панель свойств поверх scroll (правый верхний угол)
@@ -62,23 +70,22 @@ pub fn canvasView(canvas: *Canvas, selected_object_id: ?u64, content_rect_scale:
                        @src(),
                        .{ .dir = .horizontal },
                        .{
-                            .expand = .none,
-                            .background = false,
                            .gravity_x = 1.0,
                            .gravity_y = 0.0,
-                            .margin = dvui.Rect{ .w = 32, .y = 16, .h = 100 },
                        },
                    );
                    {
                        drawPropertiesPanel(canvas, obj);
-                    }
                        // Сохраняем rect панели свойств для следующего кадра — в handleCanvasMouse исключаем из него клики
                        canvas.properties_rect_scale = properties_box.data().contentRectScale();
+                    }
                    properties_box.deinit();
                }
            }

-            dvui.label(@src(), "Canvas", .{}, .{ .gravity_x = 0.5, .gravity_y = 0.0 });
+            drawCanvasLabelPanel();
+            if (canvas.show_render_stats)
+                drawStatsPanel(canvas.render_engine.getStats(), canvas.frame_index);

            if (canvas.properties_rect_scale) |prs| {
                for (dvui.events()) |*e| {
@@ -94,7 +101,7 @@ pub fn canvasView(canvas: *Canvas, selected_object_id: ?u64, content_rect_scale:
                }
            }

-            if (!scroll.init_opts.process_events_after) {
+            if (!init_options.process_events_after) {
                if (scroll.scroll) |*sc| {
                    dvui.clipSet(sc.prevClip);
                    sc.processEventsAfter();
@@ -278,6 +285,7 @@ fn drawToolbar(canvas: *Canvas) void {
            .corner_radius = dvui.Rect.all(8),
            .background = true,
            .color_fill = dvui.Color.black.opacity(0.2),
+            .margin = dvui.Rect{ .x = 16, .y = 16 },
        },
    );
    {
@@ -305,13 +313,13 @@ fn drawPropertiesPanel(canvas: *Canvas, selected_object: *Document.Object) void
        @src(),
        .{ .dir = .vertical },
        .{
-            .gravity_x = 1.0,
-            .gravity_y = 0.0,
            .padding = dvui.Rect.all(8),
            .corner_radius = dvui.Rect.all(8),
            .background = true,
            .color_fill = dvui.Color.black.opacity(0.2),
-            .min_size_content = .{ .w = 220 },
+            .min_size_content = .width(300),
+            .max_size_content = .width(300),
+            .margin = dvui.Rect{ .w = 32, .y = 16, .h = 100 },
        },
    );
    {
@@ -332,35 +340,81 @@ fn drawPropertiesPanel(canvas: *Canvas, selected_object: *Document.Object) void
    panel.deinit();
 }

+fn drawCanvasLabelPanel() void {
+    var panel = dvui.box(
+        @src(),
+        .{ .dir = .vertical },
+        .{
+            .gravity_x = 0.5,
+            .gravity_y = 0.0,
+            .padding = dvui.Rect.all(8),
+            .corner_radius = dvui.Rect.all(8),
+            .background = true,
+            .color_fill = dvui.Color.black.opacity(0.2),
+            .margin = dvui.Rect{ .x = 16, .y = 16 },
+        },
+    );
+    {
+        dvui.label(@src(), "Canvas", .{}, .{});
+    }
+    panel.deinit();
+}
+
+fn drawStatsPanel(stats: RenderStats, frame_index: u64) void {
+    var panel = dvui.box(
+        @src(),
+        .{ .dir = .vertical },
+        .{
+            .gravity_x = 0.0,
+            .gravity_y = 1.0,
+            .padding = dvui.Rect.all(8),
+            .corner_radius = dvui.Rect.all(8),
+            .background = true,
+            .color_fill = dvui.Color.black.opacity(0.2),
+            .margin = dvui.Rect{ .x = 16, .h = 16 },
+        },
+    );
+    {
+        dvui.label(@src(), "Frame time: {d:.2}ms", .{@as(f32, @floatFromInt(stats.render_time_ns)) / std.time.ns_per_ms}, .{});
+        dvui.label(@src(), "Frame index: {}", .{frame_index}, .{});
+    }
+    panel.deinit();
+}
+
+fn applyPropertyPatch(canvas: *Canvas, obj: *Document.Object, patch: Property) void {
+    obj.setProperty(canvas.allocator, patch) catch {};
+    canvas.requestRedraw();
+}
+
 fn drawPropertyEditor(canvas: *Canvas, obj: *Document.Object, prop: *const Property, row_index: usize) void {
    const row_id: usize = row_index * 16;
+    const is_even = row_index % 2 == 0;
    var row = dvui.box(
        @src(),
        .{ .dir = .vertical },
        .{
            .id_extra = row_id,
            .expand = .horizontal,
-            .padding = dvui.Rect{ .y = 2 },
+            .padding = dvui.Rect{ .y = 2, .x = 4 },
+            .corner_radius = dvui.Rect.all(4),
+            .background = is_even,
+            .color_fill = if (is_even) dvui.Color.black.opacity(0.4) else .{},
        },
    );
    {
        const tag = std.meta.activeTag(prop.data);
+
        dvui.labelNoFmt(@src(), propertyLabel(tag), .{}, .{});

        switch (prop.data) {
            .position => |pos| {
                var next = pos;
-                const doc = canvas.document;
-                const min_x = -doc.size.w;
-                const max_x = doc.size.w;
-                const min_y = -doc.size.h;
-                const max_y = doc.size.h;
                var changed = false;
                {
                    var subrow = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .horizontal });
                    dvui.labelNoFmt(@src(), "x:", .{}, .{});
                    const T = @TypeOf(next.x);
-                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.x, .min = @as(T, min_x), .max = @as(T, max_x) }, .{ .expand = .horizontal });
+                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.x }, .{ .expand = .horizontal });
                    subrow.deinit();
                    changed = res.changed or changed;
                }
@@ -368,13 +422,12 @@ fn drawPropertyEditor(canvas: *Canvas, obj: *Document.Object, prop: *const Prope
                    var subrow = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .horizontal });
                    dvui.labelNoFmt(@src(), "y:", .{}, .{});
                    const T = @TypeOf(next.y);
-                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.y, .min = @as(T, min_y), .max = @as(T, max_y) }, .{ .expand = .horizontal });
+                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.y }, .{ .expand = .horizontal });
                    subrow.deinit();
                    changed = res.changed or changed;
                }
                if (changed) {
-                    obj.setProperty(canvas.document.allocator, .{ .data = .{ .position = next } }) catch {};
-                    canvas.requestRedraw();
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .position = next } });
                }
            },
            .angle => |angle| {
@@ -387,8 +440,7 @@ fn drawPropertyEditor(canvas: *Canvas, obj: *Document.Object, prop: *const Prope
                    subrow.deinit();
                    if (res.changed) {
                        next = degrees * std.math.pi / 180.0;
-                        obj.setProperty(canvas.document.allocator, .{ .data = .{ .angle = next } }) catch {};
-                        canvas.requestRedraw();
+                        applyPropertyPatch(canvas, obj, .{ .data = .{ .angle = next } });
                    }
                }
            },
@@ -412,40 +464,35 @@ fn drawPropertyEditor(canvas: *Canvas, obj: *Document.Object, prop: *const Prope
                    changed = res.changed or changed;
                }
                if (changed) {
-                    obj.setProperty(canvas.document.allocator, .{ .data = .{ .scale = next } }) catch {};
-                    canvas.requestRedraw();
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .scale = next } });
                }
            },
            .visible => |v| {
                var next = v;
                if (dvui.checkbox(@src(), &next, "Visible", .{})) {
-                    obj.setProperty(canvas.document.allocator, .{ .data = .{ .visible = next } }) catch {};
-                    canvas.requestRedraw();
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .visible = next } });
                }
            },
            .opacity => |opacity| {
                var next = opacity;
                if (dvui.sliderEntry(@src(), "{d:0.2}", .{ .value = &next, .min = 0.0, .max = 1.0, .interval = 0.01 }, .{ .expand = .horizontal })) {
-                    obj.setProperty(canvas.document.allocator, .{ .data = .{ .opacity = next } }) catch {};
-                    canvas.requestRedraw();
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .opacity = next } });
                }
            },
            .locked => |v| {
                var next = v;
                if (dvui.checkbox(@src(), &next, "Locked", .{})) {
-                    obj.setProperty(canvas.document.allocator, .{ .data = .{ .locked = next } }) catch {};
-                    canvas.requestRedraw();
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .locked = next } });
                }
            },
            .size => |size| {
                var next = size;
-                const doc = canvas.document;
                var changed = false;
                {
                    var subrow = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .horizontal });
                    dvui.labelNoFmt(@src(), "w:", .{}, .{});
                    const T = @TypeOf(next.w);
-                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.w, .min = @as(T, 0.0), .max = @as(T, doc.size.w) }, .{ .expand = .horizontal });
+                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.w, .min = @as(T, 0.0) }, .{ .expand = .horizontal });
                    subrow.deinit();
                    changed = res.changed or changed;
                }
@@ -453,24 +500,22 @@ fn drawPropertyEditor(canvas: *Canvas, obj: *Document.Object, prop: *const Prope
                    var subrow = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .horizontal });
                    dvui.labelNoFmt(@src(), "h:", .{}, .{});
                    const T = @TypeOf(next.h);
-                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.h, .min = @as(T, 0.0), .max = @as(T, doc.size.h) }, .{ .expand = .horizontal });
+                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.h, .min = @as(T, 0.0) }, .{ .expand = .horizontal });
                    subrow.deinit();
                    changed = res.changed or changed;
                }
                if (changed) {
-                    obj.setProperty(canvas.document.allocator, .{ .data = .{ .size = next } }) catch {};
-                    canvas.requestRedraw();
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .size = next } });
                }
            },
            .radii => |radii| {
                var next = radii;
-                const doc = canvas.document;
                var changed = false;
                {
                    var subrow = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .horizontal });
                    dvui.labelNoFmt(@src(), "x:", .{}, .{});
                    const T = @TypeOf(next.x);
-                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.x, .min = @as(T, 0.0), .max = @as(T, doc.size.w) }, .{ .expand = .horizontal });
+                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.x, .min = @as(T, 0.0) }, .{ .expand = .horizontal });
                    subrow.deinit();
                    changed = res.changed or changed;
                }
@@ -478,28 +523,28 @@ fn drawPropertyEditor(canvas: *Canvas, obj: *Document.Object, prop: *const Prope
                    var subrow = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .horizontal });
                    dvui.labelNoFmt(@src(), "y:", .{}, .{});
                    const T = @TypeOf(next.y);
-                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.y, .min = @as(T, 0.0), .max = @as(T, doc.size.h) }, .{ .expand = .horizontal });
+                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.y, .min = @as(T, 0.0) }, .{ .expand = .horizontal });
                    subrow.deinit();
                    changed = res.changed or changed;
                }
                if (changed) {
-                    obj.setProperty(canvas.document.allocator, .{ .data = .{ .radii = next } }) catch {};
-                    canvas.requestRedraw();
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .radii = next } });
+                }
+            },
+            .arc_percent => |pct| {
+                var next = pct;
+                if (dvui.sliderEntry(@src(), "{d:0.0}%", .{ .value = &next, .min = 0.0, .max = 100.0, .interval = 1.0 }, .{ .expand = .horizontal })) {
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .arc_percent = next } });
                }
            },
            .end_point => |pt| {
                var next = pt;
-                const doc = canvas.document;
-                const min_x = -doc.size.w;
-                const max_x = doc.size.w;
-                const min_y = -doc.size.h;
-                const max_y = doc.size.h;
                var changed = false;
                {
                    var subrow = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .horizontal });
                    dvui.labelNoFmt(@src(), "x:", .{}, .{});
                    const T = @TypeOf(next.x);
-                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.x, .min = @as(T, min_x), .max = @as(T, max_x) }, .{ .expand = .horizontal });
+                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.x }, .{ .expand = .horizontal });
                    subrow.deinit();
                    changed = res.changed or changed;
                }
@@ -507,17 +552,137 @@ fn drawPropertyEditor(canvas: *Canvas, obj: *Document.Object, prop: *const Prope
                    var subrow = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .horizontal });
                    dvui.labelNoFmt(@src(), "y:", .{}, .{});
                    const T = @TypeOf(next.y);
-                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.y, .min = @as(T, min_y), .max = @as(T, max_y) }, .{ .expand = .horizontal });
+                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next.y }, .{ .expand = .horizontal });
                    subrow.deinit();
                    changed = res.changed or changed;
                }
                if (changed) {
-                    obj.setProperty(canvas.document.allocator, .{ .data = .{ .end_point = next } }) catch {};
-                    canvas.requestRedraw();
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .end_point = next } });
                }
            },
            .points => |points| {
-                dvui.label(@src(), "Points: {d}", .{points.items.len}, .{});
+                var list = std.ArrayList(Point2_f).empty;
+                list.appendSlice(canvas.allocator, points) catch {
+                    dvui.label(@src(), "Points: {d}", .{points.len}, .{});
+                    return;
+                };
+                defer list.deinit(canvas.allocator);
+                dvui.label(@src(), "Points: {d}", .{list.items.len}, .{});
+
+                var changed = false;
+                var to_delete: ?usize = null;
+
+                for (list.items, 0..) |*pt, i| {
+                    // Одна строка: крестик удаления + paned с X/Y пополам
+                    var subrow = dvui.box(
+                        @src(),
+                        .{ .dir = .horizontal },
+                        .{
+                            .expand = .horizontal,
+                            .id_extra = i,
+                        },
+                    );
+                    {
+                        // Крестик удаления
+                        if (dvui.buttonIcon(@src(), "Delete", icons.cross, .{}, .{}, .{
+                            .id_extra = i,
+                            .gravity_y = 0.5,
+                            .margin = .{
+                                .x = 8,
+                            },
+                        })) {
+                            to_delete = i;
+                        }
+
+                        // Панель с X и Y, разделёнными пополам
+                        var split_ratio: f32 = 0.5;
+                        var paned = dvui.paned(
+                            @src(),
+                            .{
+                                .direction = .horizontal,
+                                .collapsed_size = 0.0,
+                                .split_ratio = &split_ratio,
+                                .handle_size = 0,
+                            },
+                            .{
+                                .expand = .horizontal,
+                            },
+                        );
+                        {
+                            if (paned.showFirst()) {
+                                var x_box = dvui.box(
+                                    @src(),
+                                    .{ .dir = .horizontal },
+                                    .{ .expand = .both },
+                                );
+                                {
+                                    dvui.labelNoFmt(@src(), "x:", .{}, .{
+                                        .gravity_y = 0.5,
+                                    });
+                                    const Tx = @TypeOf(pt.x);
+                                    const res_x = dvui.textEntryNumber(
+                                        @src(),
+                                        Tx,
+                                        .{ .value = &pt.x },
+                                        .{ .expand = .horizontal },
+                                    );
+                                    changed = res_x.changed or changed;
+                                }
+                                x_box.deinit();
+                            }
+
+                            if (paned.showSecond()) {
+                                var y_box = dvui.box(
+                                    @src(),
+                                    .{ .dir = .horizontal },
+                                    .{ .expand = .both },
+                                );
+                                {
+                                    dvui.labelNoFmt(@src(), "y:", .{}, .{
+                                        .gravity_y = 0.5,
+                                    });
+                                    const Ty = @TypeOf(pt.y);
+                                    const res_y = dvui.textEntryNumber(
+                                        @src(),
+                                        Ty,
+                                        .{ .value = &pt.y },
+                                        .{ .expand = .horizontal },
+                                    );
+                                    changed = res_y.changed or changed;
+                                }
+                                y_box.deinit();
+                            }
+                        }
+                        paned.deinit();
+                    }
+                    subrow.deinit();
+                }
+
+                // Удаление выбранной точки
+                if (to_delete) |idx| {
+                    _ = list.orderedRemove(idx);
+                    changed = true;
+                }
+
+                // Кнопка добавления новой точки (одна на весь список)
+                if (dvui.button(@src(), "Add point", .{}, .{})) {
+                    const T = @TypeOf(list.items[0]);
+                    const new_point: T = if (list.items.len > 0)
+                        list.items[list.items.len - 1]
+                    else
+                        .{ .x = 0, .y = 0 };
+                    list.append(canvas.allocator, new_point) catch {};
+                    changed = true;
+                }
+
+                if (changed) {
+                    const slice = canvas.allocator.dupe(Point2_f, list.items) catch return;
+                    obj.setProperty(canvas.allocator, .{ .data = .{ .points = slice } }) catch {
+                        canvas.allocator.free(slice);
+                        return;
+                    };
+                    canvas.requestRedraw();
+                }
            },
            .fill_rgba => |rgba| {
                drawColorEditor(canvas, obj, rgba, true);
@@ -534,11 +699,22 @@ fn drawPropertyEditor(canvas: *Canvas, obj: *Document.Object, prop: *const Prope
                    const res = dvui.textEntryNumber(@src(), T, .{ .value = &next, .min = @as(T, 0.0), .max = @as(T, 100.0) }, .{ .expand = .horizontal });
                    subrow.deinit();
                    if (res.changed) {
-                        obj.setProperty(canvas.document.allocator, .{ .data = .{ .thickness = next } }) catch {};
-                        canvas.requestRedraw();
+                        applyPropertyPatch(canvas, obj, .{ .data = .{ .thickness = next } });
                    }
                }
            },
+            .closed => |v| {
+                var next = v;
+                if (dvui.checkbox(@src(), &next, "Closed", .{})) {
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .closed = next } });
+                }
+            },
+            .filled => |v| {
+                var next = v;
+                if (dvui.checkbox(@src(), &next, "Filled", .{})) {
+                    applyPropertyPatch(canvas, obj, .{ .data = .{ .filled = next } });
+                }
+            },
        }
    }
    row.deinit();
@@ -552,12 +728,11 @@ fn drawColorEditor(canvas: *Canvas, obj: *Document.Object, rgba: u32, is_fill: b
        .{ .expand = .horizontal },
    )) {
        const next = colorToRgba(hsv.toColor());
-        if (is_fill) {
-            obj.setProperty(canvas.document.allocator, .{ .data = .{ .fill_rgba = next } }) catch {};
-        } else {
-            obj.setProperty(canvas.document.allocator, .{ .data = .{ .stroke_rgba = next } }) catch {};
-        }
-        canvas.requestRedraw();
+        const patch: Property = if (is_fill)
+            .{ .data = .{ .fill_rgba = next } }
+        else
+            .{ .data = .{ .stroke_rgba = next } };
+        applyPropertyPatch(canvas, obj, patch);
    }
 }

@@ -571,11 +746,14 @@ fn propertyLabel(tag: std.meta.Tag(PropertyData)) []const u8 {
        .locked => "Locked",
        .size => "Size",
        .radii => "Radii",
+        .arc_percent => "Arc %",
        .end_point => "End point",
        .points => "Points",
        .fill_rgba => "Fill color",
        .stroke_rgba => "Stroke color",
        .thickness => "Thickness",
+        .closed => "Closed",
+        .filled => "Filled",
    };
 }

--- a/src/ui/frame.zig
+++ b/src/ui/frame.zig
@@ -30,6 +30,5 @@ pub fn guiFrame(ctx: *WindowContext) bool {
    }
    root.deinit();

-    ctx.frame_index += 1;
    return true;
 }
--- a/src/ui/left_panel.zig
+++ b/src/ui/left_panel.zig
@@ -19,7 +19,6 @@ fn shapeLabel(shape: Object.ShapeKind) []const u8 {
    return switch (shape) {
        .line => "Line",
        .ellipse => "Ellipse",
-        .arc => "Arc",
        .broken => "Broken line",
    };
 }
@@ -122,7 +121,7 @@ fn objectTree(ctx: *WindowContext) void {
                    }
                },
                .delete => |obj_id| {
-                    _ = doc.removeObjectById(obj_id);
+                    _ = doc.removeObjectById(ctx.allocator, obj_id);
                    if (open_doc.selected_object_id == obj_id)
                        open_doc.selected_object_id = null;
                    open_doc.canvas.requestRedraw();
@@ -175,6 +174,19 @@ pub fn leftPanel(ctx: *WindowContext) void {
                if (dvui.checkbox(@src(), &canvas.draw_document, "Draw document", .{})) {
                    canvas.requestRedraw();
                }
+                if (dvui.checkbox(@src(), &canvas.show_render_stats, "Show stats", .{})) {}
+                {
+                    dvui.label(@src(), "Rendering quality", .{}, .{});
+                    var quality = canvas.getRenderingQuality();
+                    if (dvui.sliderEntry(
+                        @src(),
+                        "{d:0.0}%",
+                        .{ .value = &quality, .min = 1.0, .max = 100.0, .interval = 1.0 },
+                        .{ .expand = .horizontal },
+                    )) {
+                        canvas.setRenderingQuality(quality);
+                    }
+                }
                if (!canvas.draw_document) {
                    if (dvui.button(@src(), if (doc.cpu_render.type == .Gradient) "Gradient" else "Squares", .{}, .{})) {
                        if (doc.cpu_render.type == .Gradient) {
@@ -188,6 +200,9 @@ pub fn leftPanel(ctx: *WindowContext) void {
                if (dvui.button(@src(), "Add random shapes", .{}, .{})) {
                    canvas.addRandomShapes() catch {};
                }
+                if (dvui.button(@src(), "Request redraw", .{}, .{})) {
+                    canvas.requestRedraw();
+                }
            } else {
                dvui.label(@src(), "No document", .{}, .{});
            }
@@ -207,11 +222,13 @@ pub fn leftPanel(ctx: *WindowContext) void {
            },
        );
        {
-            dvui.label(@src(), "Objects", .{}, .{ .font = .{
-                .id = dvui.themeGet().font_heading.id,
+            dvui.label(@src(), "Objects", .{}, .{
+                .font = .{
                    .line_height_factor = dvui.themeGet().font_heading.line_height_factor,
                    .size = dvui.themeGet().font_heading.size + 8,
-            }, .gravity_x = 0.5 });
+                },
+                .gravity_x = 0.5,
+            });
            var scroll = dvui.scrollArea(
                @src(),
                .{ .vertical = .auto, .horizontal = .auto },
--- a/src/ui/menu_bar.zig
+++ b/src/ui/menu_bar.zig
@@ -1,7 +1,8 @@
 const std = @import("std");
 const dvui = @import("dvui");
 const WindowContext = @import("../WindowContext.zig");
-const document_json = @import("../persistence/document_json.zig");
+const Document = @import("../models/Document.zig");
+const json_io = @import("../persistence/json_io.zig");

 pub fn menuBar(ctx: *WindowContext) void {
    var m = dvui.menu(@src(), .horizontal, .{ .background = true, .expand = .horizontal });
@@ -35,7 +36,7 @@ fn openDocumentDialog(ctx: *WindowContext) void {
    defer ctx.allocator.free(path_z);

    const path = path_z[0..path_z.len];
-    const doc = document_json.loadFromFile(ctx.allocator, path) catch |err| {
+    const doc = json_io.loadFromFile(Document, ctx.allocator, path) catch |err| {
        std.debug.print("Open file error: {}\n", .{err});
        return;
    };
@@ -58,7 +59,7 @@ fn saveAsDialog(ctx: *WindowContext) void {
    defer ctx.allocator.free(path_z);

    const path_raw = path_z[0..path_z.len];
-    document_json.saveToFile(&open_doc.document, path_raw) catch |err| {
+    json_io.saveToFile(Document, &open_doc.document, path_raw) catch |err| {
        std.debug.print("Save file error: {}\n", .{err});
        return;
    };
Author	SHA1	Message	Date
andrew.kraevskii	d6c8a062cd	Fix memory leaks found by DebugAllocator.	2026-03-04 02:00:40 +03:00
andrew.kraevskii	045624beac	Use leak detection of DebugAllocator. When allocating memory it remebers where memory was allocated but it only for leaks in .deinit(). So not calling it is a sure way to miss a bunch of leaks. deinit() returns if it found leaks but we don't really care. Its usefull for tests but not here.	2026-03-04 02:00:40 +03:00
andrew.kraevskii	b0259c5788	Stuff.	2026-03-04 02:00:40 +03:00
andrew.kraevskii	0a47ea1e43	If function doesn't do anything related to object just don't pass object to it	2026-03-04 02:00:40 +03:00
andrew.kraevskii	cc10d806fe	Return type of field of property instead of property.	2026-03-04 02:00:40 +03:00
andrew.kraevskii	e3a4506194	Use std.mem.Allocator.dupe instead of @memcpy.	2026-03-04 02:00:40 +03:00
andrew.kraevskii	3348b2e91c	Update to latest dvui.	2026-03-04 02:00:40 +03:00
andrew.kraevskii	9ca360c6b3	Im trying not to die of old age waiting on llvm :(	2026-03-04 02:00:21 +03:00
Roman Pytkov	2e2c140d5b	applyPropertyPatch	2026-03-03 20:46:23 +03:00
Roman Pytkov	129206ce4f	Очистка	2026-03-03 20:39:01 +03:00
Roman Pytkov	446cd80616	points теперь слайс	2026-03-03 20:38:57 +03:00
Roman Pytkov	9a795c22f1	Изменён лимит частоты перерисовки	2026-03-03 20:10:30 +03:00
Roman Pytkov	84c9a55ee5	refactor: Удалена нереализованная фигура "Дуга" Полностью удалены модель, инструменты, рендеринг и связанные UI-элементы для фигуры "Дуга", поскольку она не была реализована в системе. Также обновлены иконки для инструментов "Линия" и "Ломаная линия".	2026-03-03 20:07:03 +03:00
Roman Pytkov	4bb98f1f41	заливка круга и closed	2026-03-03 19:59:50 +03:00
Roman Pytkov	d6d41388b3	Небольшое упрощение	2026-03-03 19:46:50 +03:00
Roman Pytkov	4bf92356af	Первый крутой круг	2026-03-03 19:07:53 +03:00
Roman Pytkov	b1177265ea	Универсальная растровая заливка	2026-03-03 18:30:24 +03:00
Roman Pytkov	5b1b3a8c5e	Переход на i32	2026-03-03 15:26:01 +03:00
Roman Pytkov	7aa9673b44	Более красивая панель	2026-03-03 14:32:20 +03:00
Roman Pytkov	32cffb757d	Заливка и замкнутая фигура	2026-03-03 14:21:55 +03:00
Roman Pytkov	e5b8e6735d	Render Quality	2026-03-02 22:43:09 +03:00
Roman Pytkov	c399d285fb	Кнопки для точек на кривой	2026-03-02 22:22:47 +03:00
Roman Pytkov	d1722e3b6b	работающее сохранение	2026-03-02 17:50:05 +03:00
Roman Pytkov	37eea6ed89	Нормальный json	2026-03-02 17:37:00 +03:00
Roman Pytkov	8ea5d97c2d	Начало фикса json	2026-03-02 17:19:55 +03:00
Roman Pytkov	b692539a30	формат 0.00 для времени кадра	2026-03-01 17:57:58 +03:00
Roman Pytkov	9fa13fa913	статистика времени кадра	2026-03-01 17:19:52 +03:00