fix: finalize placeholder instances in class factory wrappers

Author: nazarhussain

examples/js_dsl/mod.test.ts

@@ -272,6 +272,31 @@ describe("optional parameters", () => {
 	});
 });
 
+describe("factory cleanup", () => {
+	it("static factory deinitializes constructor placeholder", () => {
+		const initBefore = mod.getFactoryResourceInitCount();
+		const deinitBefore = mod.getFactoryResourceDeinitCount();
+
+		const resource = mod.FactoryResource.withByte(7);
+
+		expect(resource.getByte()).toEqual(7);
+		expect(mod.getFactoryResourceInitCount()).toEqual(initBefore + 2);
+		expect(mod.getFactoryResourceDeinitCount()).toEqual(deinitBefore + 1);
+	});
+
+	it("instance factory deinitializes constructor placeholder", () => {
+		const base = mod.FactoryResource.withByte(1);
+		const initBefore = mod.getFactoryResourceInitCount();
+		const deinitBefore = mod.getFactoryResourceDeinitCount();
+
+		const clone = base.cloneWithByte(9);
+
+		expect(clone.getByte()).toEqual(9);
+		expect(mod.getFactoryResourceInitCount()).toEqual(initBefore + 2);
+		expect(mod.getFactoryResourceDeinitCount()).toEqual(deinitBefore + 1);
+	});
+});
+
 // Section 15: Getters and Setters
 describe("Settings class (getters/setters)", () => {
 	it("has getter for volume with default value", () => {

examples/js_dsl/mod.zig

@@ -308,6 +308,24 @@ pub fn getEnvRefcount() Number {
 // Section 13: Static Factory Methods + Optional Parameters
 // ============================================================================
 
+var factory_resource_init_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0);
+var factory_resource_deinit_count: std.atomic.Value(u32) = std.atomic.Value(u32).init(0);
+
+fn makeFactoryResource(byte: u8) !FactoryResource {
+    const data = try js.allocator().alloc(u8, 1);
+    data[0] = byte;
+    _ = factory_resource_init_count.fetchAdd(1, .monotonic);
+    return .{ .data = data };
+}
+
+pub fn getFactoryResourceInitCount() Number {
+    return Number.from(@as(i32, @intCast(factory_resource_init_count.load(.acquire))));
+}
+
+pub fn getFactoryResourceDeinitCount() Number {
+    return Number.from(@as(i32, @intCast(factory_resource_deinit_count.load(.acquire))));
+}
+
 /// A point class demonstrating static factories and optional params.
 pub const Point = struct {
     pub const js_class = true;
@@ -349,6 +367,34 @@ pub const Point = struct {
     }
 };
 
+/// A resource-owning class used to verify placeholder cleanup in factory paths.
+pub const FactoryResource = struct {
+    pub const js_class = true;
+    data: []u8,
+
+    pub fn init() !FactoryResource {
+        return makeFactoryResource(0);
+    }
+
+    pub fn withByte(value: Number) !FactoryResource {
+        return makeFactoryResource(@intCast(value.assertU32()));
+    }
+
+    pub fn cloneWithByte(self: FactoryResource, value: Number) !FactoryResource {
+        _ = self;
+        return makeFactoryResource(@intCast(value.assertU32()));
+    }
+
+    pub fn getByte(self: FactoryResource) Number {
+        return Number.from(@as(i32, @intCast(self.data[0])));
+    }
+
+    pub fn deinit(self: *FactoryResource) void {
+        _ = factory_resource_deinit_count.fetchAdd(1, .monotonic);
+        js.allocator().free(self.data);
+    }
+};
+
 // ============================================================================
 // Module Export
 // ============================================================================

src/js/wrap_class.zig

@@ -49,14 +49,18 @@ pub fn wrapClass(comptime T: type) type {
         /// C-ABI constructor callback for napi_define_class.
         pub const constructor: napi.c.napi_callback = genConstructor();
 
-        /// Default GC-invoked destructor. Frees the native object using c_allocator.
-        pub fn defaultFinalize(_: napi.Env, obj: *T, _: ?*anyopaque) void {
+        fn destroyNativeObject(obj: *T) void {
             if (@hasDecl(T, "deinit")) {
                 obj.deinit();
             }
             std.heap.c_allocator.destroy(obj);
         }
 
+        /// Default GC-invoked destructor. Frees the native object using c_allocator.
+        pub fn defaultFinalize(_: napi.Env, obj: *T, _: ?*anyopaque) void {
+            destroyNativeObject(obj);
+        }
+
         fn isClassSelfParam(comptime ParamType: type) bool {
             return ParamType == *T or ParamType == *const T or ParamType == T;
         }
@@ -620,7 +624,7 @@ pub fn wrapClass(comptime T: type) type {
                         e.throwError("", "Failed to remove constructor wrap in instance factory") catch {};
                         return null;
                     };
-                    std.heap.c_allocator.destroy(old_ptr);
+                    destroyNativeObject(old_ptr);
 
                     // Wrap with the factory's result
                     _ = e.wrap(instance_napi, Class, obj_ptr, defaultFinalize, null, null) catch {
@@ -837,8 +841,8 @@ pub fn wrapClass(comptime T: type) type {
                         e.throwError("", "Failed to remove constructor wrap in factory") catch {};
                         return null;
                     };
-                    // The constructor allocated this — free it since we're replacing
-                    std.heap.c_allocator.destroy(old_ptr);
+                    // The constructor allocated this — destroy it via the same path as GC finalization.
+                    destroyNativeObject(old_ptr);
 
                     // Wrap with the factory's result
                     _ = e.wrap(instance_val, Class, obj_ptr, defaultFinalize, null, null) catch {