G2(partial): instantiate panel-clades Zig FFI {{project}}->panel_clades

Consistency fix (the exact thing Axiom got wrong): build.zig +
integration_test.zig now use panel_clades_* matching main.zig exports
and Foreign.idr (C:panel_clades_*, libpanel_clades). Remaining: same
mechanical Zig-0.15 drift class as Axiom (addSharedLibrary->addLibrary,
callconv(.C)->.c, opaque-with-fields) — tracked, not yet applied.

Author: hyperpolymath

panel-clades/ffi/zig/build.zig

@@ -9,7 +9,7 @@ pub fn build(b: *std.Build) void {
 
     // Shared library (.so, .dylib, .dll)
     const lib = b.addSharedLibrary(.{
-        .name = "{{project}}",
+        .name = "panel_clades",
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
@@ -20,7 +20,7 @@ pub fn build(b: *std.Build) void {
 
     // Static library (.a)
     const lib_static = b.addStaticLibrary(.{
-        .name = "{{project}}",
+        .name = "panel_clades",
         .root_source_file = b.path("src/main.zig"),
         .target = target,
         .optimize = optimize,
@@ -32,8 +32,8 @@ pub fn build(b: *std.Build) void {
 
     // Generate header file for C compatibility
     const header = b.addInstallHeader(
-        b.path("include/{{project}}.h"),
-        "{{project}}.h",
+        b.path("include/panel_clades.h"),
+        "panel_clades.h",
     );
     b.getInstallStep().dependOn(&header.step);
 
@@ -79,7 +79,7 @@ pub fn build(b: *std.Build) void {
 
     // Benchmark (if needed)
     const bench = b.addExecutable(.{
-        .name = "{{project}}-bench",
+        .name = "panel_clades-bench",
         .root_source_file = b.path("bench/bench.zig"),
         .target = target,
         .optimize = .ReleaseFast,

panel-clades/ffi/zig/test/integration_test.zig

@@ -7,36 +7,36 @@ const std = @import("std");
 const testing = std.testing;
 
 // Import FFI functions
-extern fn {{project}}_init() ?*opaque {};
-extern fn {{project}}_free(?*opaque {}) void;
-extern fn {{project}}_process(?*opaque {}, u32) c_int;
-extern fn {{project}}_get_string(?*opaque {}) ?[*:0]const u8;
-extern fn {{project}}_free_string(?[*:0]const u8) void;
-extern fn {{project}}_last_error() ?[*:0]const u8;
-extern fn {{project}}_version() [*:0]const u8;
-extern fn {{project}}_is_initialized(?*opaque {}) u32;
+extern fn panel_clades_init() ?*opaque {};
+extern fn panel_clades_free(?*opaque {}) void;
+extern fn panel_clades_process(?*opaque {}, u32) c_int;
+extern fn panel_clades_get_string(?*opaque {}) ?[*:0]const u8;
+extern fn panel_clades_free_string(?[*:0]const u8) void;
+extern fn panel_clades_last_error() ?[*:0]const u8;
+extern fn panel_clades_version() [*:0]const u8;
+extern fn panel_clades_is_initialized(?*opaque {}) u32;
 
 //==============================================================================
 // Lifecycle Tests
 //==============================================================================
 
 test "create and destroy handle" {
-    const handle = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(handle);
+    const handle = panel_clades_init() orelse return error.InitFailed;
+    defer panel_clades_free(handle);
 
     try testing.expect(handle != null);
 }
 
 test "handle is initialized" {
-    const handle = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(handle);
+    const handle = panel_clades_init() orelse return error.InitFailed;
+    defer panel_clades_free(handle);
 
-    const initialized = {{project}}_is_initialized(handle);
+    const initialized = panel_clades_is_initialized(handle);
     try testing.expectEqual(@as(u32, 1), initialized);
 }
 
 test "null handle is not initialized" {
-    const initialized = {{project}}_is_initialized(null);
+    const initialized = panel_clades_is_initialized(null);
     try testing.expectEqual(@as(u32, 0), initialized);
 }
 
@@ -45,15 +45,15 @@ test "null handle is not initialized" {
 //==============================================================================
 
 test "process with valid handle" {
-    const handle = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(handle);
+    const handle = panel_clades_init() orelse return error.InitFailed;
+    defer panel_clades_free(handle);
 
-    const result = {{project}}_process(handle, 42);
+    const result = panel_clades_process(handle, 42);
     try testing.expectEqual(@as(c_int, 0), result); // 0 = ok
 }
 
 test "process with null handle returns error" {
-    const result = {{project}}_process(null, 42);
+    const result = panel_clades_process(null, 42);
     try testing.expectEqual(@as(c_int, 4), result); // 4 = null_pointer
 }
 
@@ -62,17 +62,17 @@ test "process with null handle returns error" {
 //==============================================================================
 
 test "get string result" {
-    const handle = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(handle);
+    const handle = panel_clades_init() orelse return error.InitFailed;
+    defer panel_clades_free(handle);
 
-    const str = {{project}}_get_string(handle);
-    defer if (str) |s| {{project}}_free_string(s);
+    const str = panel_clades_get_string(handle);
+    defer if (str) |s| panel_clades_free_string(s);
 
     try testing.expect(str != null);
 }
 
 test "get string with null handle" {
-    const str = {{project}}_get_string(null);
+    const str = panel_clades_get_string(null);
     try testing.expect(str == null);
 }
 
@@ -81,9 +81,9 @@ test "get string with null handle" {
 //==============================================================================
 
 test "last error after null handle operation" {
-    _ = {{project}}_process(null, 0);
+    _ = panel_clades_process(null, 0);
 
-    const err = {{project}}_last_error();
+    const err = panel_clades_last_error();
     try testing.expect(err != null);
 
     if (err) |e| {
@@ -93,10 +93,10 @@ test "last error after null handle operation" {
 }
 
 test "no error after successful operation" {
-    const handle = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(handle);
+    const handle = panel_clades_init() orelse return error.InitFailed;
+    defer panel_clades_free(handle);
 
-    _ = {{project}}_process(handle, 0);
+    _ = panel_clades_process(handle, 0);
 
     // Error should be cleared after successful operation
     // (This depends on implementation)
@@ -107,14 +107,14 @@ test "no error after successful operation" {
 //==============================================================================
 
 test "version string is not empty" {
-    const ver = {{project}}_version();
+    const ver = panel_clades_version();
     const ver_str = std.mem.span(ver);
 
     try testing.expect(ver_str.len > 0);
 }
 
 test "version string is semantic version format" {
-    const ver = {{project}}_version();
+    const ver = panel_clades_version();
     const ver_str = std.mem.span(ver);
 
     // Should be in format X.Y.Z
@@ -126,37 +126,37 @@ test "version string is semantic version format" {
 //==============================================================================
 
 test "multiple handles are independent" {
-    const h1 = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(h1);
+    const h1 = panel_clades_init() orelse return error.InitFailed;
+    defer panel_clades_free(h1);
 
-    const h2 = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(h2);
+    const h2 = panel_clades_init() orelse return error.InitFailed;
+    defer panel_clades_free(h2);
 
     try testing.expect(h1 != h2);
 
     // Operations on h1 should not affect h2
-    _ = {{project}}_process(h1, 1);
-    _ = {{project}}_process(h2, 2);
+    _ = panel_clades_process(h1, 1);
+    _ = panel_clades_process(h2, 2);
 }
 
 test "double free is safe" {
-    const handle = {{project}}_init() orelse return error.InitFailed;
+    const handle = panel_clades_init() orelse return error.InitFailed;
 
-    {{project}}_free(handle);
-    {{project}}_free(handle); // Should not crash
+    panel_clades_free(handle);
+    panel_clades_free(handle); // Should not crash
 }
 
 test "free null is safe" {
-    {{project}}_free(null); // Should not crash
+    panel_clades_free(null); // Should not crash
 }
 
 //==============================================================================
 // Thread Safety Tests (if applicable)
 //==============================================================================
 
 test "concurrent operations" {
-    const handle = {{project}}_init() orelse return error.InitFailed;
-    defer {{project}}_free(handle);
+    const handle = panel_clades_init() orelse return error.InitFailed;
+    defer panel_clades_free(handle);
 
     const ThreadContext = struct {
         h: *opaque {},
@@ -165,7 +165,7 @@ test "concurrent operations" {
 
     const thread_fn = struct {
         fn run(ctx: ThreadContext) void {
-            _ = {{project}}_process(ctx.h, ctx.id);
+            _ = panel_clades_process(ctx.h, ctx.id);
         }
     }.run;