Fix the linux CI build as well.

The 0.1.0 bundle had /Users/runner/hostedtoolcache/.../libruby.4.0.dylib
hardcoded in its install_name; dyld refused to load it on any non-CI
machine.
ld couldn't find libruby in setup-ruby's libdir and fell back to
/usr/lib, linking the .so against Ubuntu's system Ruby 3.2. That ABI
mismatch was hidden by the silent pure-Ruby fallback, which means CI
had been running fallback specs on Linux all along.

Seems that the problem is in zig_rb's build.zig polluting the exported module.

Author: yaroslav

Rakefile

@@ -31,34 +31,31 @@ task compile: :sync_version do
   fix_macos_install_names if RUBY_PLATFORM.include?("darwin")
 end
 
-# Zig's link line for the bundle picks up libruby with an absolute install
-# name (CI's hostedtoolcache, or a developer's prefix). Without rewriting,
-# dlopen on a different machine fails because the path doesn't exist.
-# Convert to @rpath form and add an rpath that resolves at load time
-# relative to the host ruby executable, then re-codesign (Apple Silicon
-# requires a valid signature; modifying load commands invalidates it).
+# Strip non-portable artifacts the Zig linker leaves in the macOS bundle:
+# absolute LC_RPATH entries (from Zig's addLibraryPath, which targets the
+# host ruby's libdir) and any absolute libruby reference that may slip back
+# in if zig_rb's contamination returns. Re-codesign because Apple Silicon
+# rejects unsigned binaries and modifying load commands invalidates the
+# signature.
 def fix_macos_install_names
   bundles = Dir["lib/carbon_fiber/*/carbon_fiber_native.bundle"]
   raise "No macOS bundles to post-process under lib/carbon_fiber/*/" if bundles.empty?
 
   bundles.each do |bundle|
     deps = `otool -L #{bundle.shellescape}`
     libruby_line = deps.lines.find { |l| l.match?(%r{/libruby\.\d+\.\d+\.dylib}) }
-    raise "No libruby reference found in #{bundle}; link layout changed?" unless libruby_line
-
-    old = libruby_line.match(/^\s*(\S.*?)\s+\(/)[1]
-    if old.start_with?("/")
-      new = "@rpath/#{File.basename(old)}"
-      sh "install_name_tool", "-change", old, new, bundle
+    if libruby_line
+      old = libruby_line.match(/^\s*(\S.*?)\s+\(/)[1]
+      if old.start_with?("/")
+        new = "@rpath/#{File.basename(old)}"
+        sh "install_name_tool", "-change", old, new, bundle
+      end
     end
 
     rpaths = `otool -l #{bundle.shellescape}`.scan(/^\s+path\s+(.+?)\s+\(offset \d+\)/).flatten
     rpaths.each do |rpath|
       sh "install_name_tool", "-delete_rpath", rpath, bundle if rpath.start_with?("/")
     end
-    unless rpaths.include?("@executable_path/../lib")
-      sh "install_name_tool", "-add_rpath", "@executable_path/../lib", bundle
-    end
 
     sh "codesign", "--sign", "-", "--force", bundle
 

build.zig

@@ -13,12 +13,32 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
+    // zig_rb's build.zig calls `zig_tests.linkSystemLibrary("ruby")` on a
+    // Compile step whose root_module is the same module exported to
+    // consumers; via the deprecated alias, that mutates the shared module's
+    // link_objects with a "ruby" system_lib. Inheriting it would bake an
+    // absolute libruby path into the macOS bundle and pull in whatever
+    // libruby Linux's ld happens to resolve (often the runner's system
+    // Ruby, breaking cross-version loads). Strip it here; Ruby's C-API
+    // symbols are resolved at dlopen against the host ruby process, like
+    // every other distributable Ruby native extension.
+    const rb_module = zig_rb_dep.module("zig_rb");
+    var i: usize = 0;
+    while (i < rb_module.link_objects.items.len) {
+        const lo = rb_module.link_objects.items[i];
+        if (lo == .system_lib and std.mem.eql(u8, lo.system_lib.name, "ruby")) {
+            _ = rb_module.link_objects.orderedRemove(i);
+        } else {
+            i += 1;
+        }
+    }
+
     const fibers_module = b.createModule(.{
         .root_source_file = b.path("ext/carbon_fiber_native/main.zig"),
         .target = target,
         .optimize = optimize,
         .imports = &.{
-            .{ .name = "rb", .module = zig_rb_dep.module("zig_rb") },
+            .{ .name = "rb", .module = rb_module },
             .{ .name = "xev", .module = libxev_dep.module("xev") },
         },
     });
@@ -38,12 +58,17 @@ pub fn build(b: *std.Build) void {
         },
     );
 
+    // macOS' linker rejects undefined symbols in shared libraries by default;
+    // Linux' ld permits them. Allow undefined Ruby C-API symbols on macOS so
+    // dyld resolves them at dlopen against the host ruby process.
+    const is_macos = target.result.os.tag == .macos;
+    if (is_macos) fibers_ext.linker_allow_shlib_undefined = true;
+
     // Enable full LTO for release builds to allow cross-module inlining between
     // the event loop, I/O helpers, and Ruby binding layers.
     // macOS excluded: Zig 0.15's linker can't resolve Xcode 26.4 TBD entries,
     // so we use DEVELOPER_DIR=/dev/null which bypasses the system SDK but also
     // prevents LLD (required for LTO) from linking against libSystem.
-    const is_macos = target.result.os.tag == .macos;
     if (optimize != .Debug and !is_macos) fibers_ext.lto = .full;
 
     const allocator = b.allocator;