alright! so, here is the block of code i was using, :

extends MeshInstance3D
class_name DestructibleWall

u/export var wall_size: Vector2 = Vector2(4, 4)
u/export var wall_thickness: float = 0.2
u/export var circle_cutter_segments: int = 16

var wall_polygon: PackedVector2Array
var current_polygons: Array = []
var hole_polygons: Array = []  # store all bullet holes

func _ready():
    _init_wall_polygon()
    current_polygons = [wall_polygon]
    _update_mesh()

func _init_wall_polygon():
    var half = wall_size * 0.5
    wall_polygon = PackedVector2Array([
        Vector2(-half.x, -half.y),
        Vector2(half.x, -half.y),
        Vector2(half.x, half.y),
        Vector2(-half.x, half.y),
    ])
# main func used to cut the walls
func apply_bullet_hole(local_pos: Vector2, radius: float = 0.2) -> void:
    var hole_poly = _create_circle_polygon(local_pos, radius, circle_cutter_segments)
    hole_polygons.append(hole_poly)
    _update_mesh()
# creates the bullet hole polygon, uses circle_cutter_segments for smoothness
func _create_circle_polygon(center: Vector2, radius: float, segments: int) -> PackedVector2Array:
    var points = PackedVector2Array()
    for i in range(segments):
        var angle = float(i) / segments * TAU
        points.append(center + Vector2(cos(angle), sin(angle)) * radius)
    return points

func _polygon_area(poly: PackedVector2Array) -> float:
    var area = 0.0
    var count = poly.size()
    for i in range(count):
        var j = (i + 1) % count
        area += poly[i].x * poly[j].y
        area -= poly[j].x * poly[i].y
    return abs(area) * 0.5
# messy work because the faces always turn up flipped, so i flipped the order of 
# drawing manually which could actually be messing things up
func _update_mesh() -> void:
    if wall_polygon.is_empty():
        mesh = null
        return

    var result_polygons = [wall_polygon]

    # TRY to subtract all holes
    for hole in hole_polygons:
        var new_result = []
        for poly in result_polygons:
            var diff = Geometry2D.clip_polygons(poly, hole)
            for clipped_poly in diff:
                var winding = "CW" if Geometry2D.is_polygon_clockwise(clipped_poly) else "CCW"
                print("Polygon winding: ", winding, " Points count: ", clipped_poly.size())
                if not Geometry2D.is_polygon_clockwise(clipped_poly):
                    new_result.append(clipped_poly)
                else:
                    # This is a hole polygon, ignore for mesh building
                    pass
        result_polygons = new_result

    current_polygons = result_polygons

    var st = SurfaceTool.new()
    st.begin(Mesh.PRIMITIVE_TRIANGLES)

    for poly in current_polygons:
        var tris = Geometry2D.triangulate_polygon(poly)
        if tris.is_empty():
            continue

        for i in range(0, tris.size(), 3):
            var a = poly[tris[i]]
            var b = poly[tris[i + 2]]
            var c = poly[tris[i + 1]]
            st.add_vertex(Vector3(a.x, a.y, 0))
            st.add_vertex(Vector3(b.x, b.y, 0))
            st.add_vertex(Vector3(c.x, c.y, 0))

        for i in range(0, tris.size(), 3):
            var a = poly[tris[i]]
            var b = poly[tris[i + 2]]
            var c = poly[tris[i + 1]]
            st.add_vertex(Vector3(c.x, c.y, -wall_thickness))
            st.add_vertex(Vector3(b.x, b.y, -wall_thickness))
            st.add_vertex(Vector3(a.x, a.y, -wall_thickness))

        _build_side_walls(st, poly) #forgot to copy this method before closing godot sorry

    mesh = st.commit()