@xincli/opentui-core 0.4.6

package/src/zig/link.zig

@@ -0,0 +1,349 @@
+const std = @import("std");
+
+pub const LinkPoolError = error{
+    OutOfMemory,
+    InvalidId,
+    WrongGeneration,
+    UrlTooLong,
+};
+
+// ID layout within 24 bits: [ generation (8 bits) | slot_index (16 bits) ]
+pub const GEN_BITS: u5 = 8;
+pub const SLOT_BITS: u5 = 16;
+pub const GEN_MASK: u32 = (@as(u32, 1) << GEN_BITS) - 1;
+pub const SLOT_MASK: u32 = (@as(u32, 1) << SLOT_BITS) - 1;
+pub const MAX_URL_LENGTH: usize = 512;
+const RETIRED_GENERATION = GEN_MASK + 1;
+
+pub const IdPayload = u32;
+
+const SlotHeader = extern struct {
+    len: u32,
+    refcount: u32,
+    generation: u32,
+};
+
+/// Simple link pool for storing URL strings with reusable IDs
+pub const LinkPool = struct {
+    allocator: std.mem.Allocator,
+    slot_capacity: u32,
+    slots_per_page: u32,
+    slot_size_bytes: usize,
+    slots: std.ArrayListUnmanaged(u8),
+    free_list: std.ArrayListUnmanaged(u32),
+    num_slots: u32,
+    retired_slot_count: u32,
+    interned_live_ids: std.StringHashMapUnmanaged(IdPayload),
+
+    pub fn init(allocator: std.mem.Allocator) LinkPool {
+        const slot_capacity = MAX_URL_LENGTH;
+        const slots_per_page = 64;
+        const slot_size_bytes = @sizeOf(SlotHeader) + slot_capacity;
+        return .{
+            .allocator = allocator,
+            .slot_capacity = slot_capacity,
+            .slots_per_page = slots_per_page,
+            .slot_size_bytes = slot_size_bytes,
+            .slots = .{},
+            .free_list = .{},
+            .num_slots = 0,
+            .retired_slot_count = 0,
+            .interned_live_ids = .{},
+        };
+    }
+
+    pub fn deinit(self: *LinkPool) void {
+        var key_it = self.interned_live_ids.keyIterator();
+        while (key_it.next()) |key_ptr| {
+            self.allocator.free(@constCast(key_ptr.*));
+        }
+        self.interned_live_ids.deinit(self.allocator);
+
+        self.slots.deinit(self.allocator);
+        self.free_list.deinit(self.allocator);
+        self.* = undefined;
+    }
+
+    fn grow(self: *LinkPool) LinkPoolError!void {
+        const slot_count_max = SLOT_MASK + 1;
+        if (self.num_slots > slot_count_max - self.slots_per_page) return LinkPoolError.OutOfMemory;
+
+        const add_bytes = self.slot_size_bytes * self.slots_per_page;
+
+        try self.slots.ensureTotalCapacity(self.allocator, self.slots.items.len + add_bytes);
+        try self.slots.appendNTimes(self.allocator, 0, add_bytes);
+
+        var i: u32 = 0;
+        while (i < self.slots_per_page) : (i += 1) {
+            try self.free_list.append(self.allocator, self.num_slots + i);
+        }
+        self.num_slots += self.slots_per_page;
+    }
+
+    fn slotPtr(self: *LinkPool, slot_index: u32) *u8 {
+        const offset: usize = @as(usize, slot_index) * self.slot_size_bytes;
+        return &self.slots.items[offset];
+    }
+
+    fn slotHeaderPtr(p: *u8) *align(1) SlotHeader {
+        return @ptrCast(p);
+    }
+
+    fn packId(slot_index: u32, generation: u32) LinkPoolError!IdPayload {
+        if (slot_index > SLOT_MASK) return LinkPoolError.OutOfMemory;
+        return ((generation & GEN_MASK) << SLOT_BITS) | (slot_index & SLOT_MASK);
+    }
+
+    fn unpackId(id: IdPayload) struct { slot_index: u32, generation: u32 } {
+        return .{
+            .slot_index = id & SLOT_MASK,
+            .generation = (id >> SLOT_BITS) & GEN_MASK,
+        };
+    }
+
+    fn removeInternedLiveId(self: *LinkPool, url: []const u8, expected_id: IdPayload) void {
+        const live_id = self.interned_live_ids.get(url) orelse return;
+        if (live_id != expected_id) return;
+        if (self.interned_live_ids.fetchRemove(url)) |removed| {
+            self.allocator.free(@constCast(removed.key));
+        }
+    }
+
+    fn lookupOrInvalidate(self: *LinkPool, url: []const u8) ?IdPayload {
+        const live_id = self.interned_live_ids.get(url) orelse return null;
+
+        const live_url = self.get(live_id) catch {
+            self.removeInternedLiveId(url, live_id);
+            return null;
+        };
+
+        if (!std.mem.eql(u8, live_url, url)) {
+            self.removeInternedLiveId(url, live_id);
+            return null;
+        }
+
+        const live_refcount = self.getRefcount(live_id) catch {
+            self.removeInternedLiveId(url, live_id);
+            return null;
+        };
+
+        if (live_refcount == 0) {
+            self.removeInternedLiveId(url, live_id);
+            return null;
+        }
+
+        return live_id;
+    }
+
+    fn internLiveId(self: *LinkPool, id: IdPayload, url: []const u8) LinkPoolError!void {
+        if (self.lookupOrInvalidate(url) != null) {
+            return;
+        }
+
+        const owned_key = self.allocator.dupe(u8, url) catch return LinkPoolError.OutOfMemory;
+        errdefer self.allocator.free(owned_key);
+
+        if (self.interned_live_ids.fetchPut(self.allocator, owned_key, id) catch return LinkPoolError.OutOfMemory) |replaced| {
+            self.allocator.free(@constCast(replaced.key));
+        }
+    }
+
+    pub fn alloc(self: *LinkPool, url: []const u8) LinkPoolError!IdPayload {
+        if (url.len > self.slot_capacity) {
+            return LinkPoolError.UrlTooLong;
+        }
+
+        if (self.lookupOrInvalidate(url)) |live_id| {
+            return live_id;
+        }
+
+        if (self.free_list.items.len == 0) try self.grow();
+
+        const slot_index = self.free_list.pop().?;
+        const p = self.slotPtr(slot_index);
+        const header_ptr = slotHeaderPtr(p);
+
+        std.debug.assert(header_ptr.generation < GEN_MASK);
+        const new_generation = header_ptr.generation + 1;
+
+        header_ptr.* = .{
+            .len = @intCast(url.len),
+            .refcount = 0,
+            .generation = new_generation,
+        };
+
+        const data_ptr = @as([*]u8, @ptrCast(p)) + @sizeOf(SlotHeader);
+        @memcpy(data_ptr[0..url.len], url);
+
+        return packId(slot_index, new_generation);
+    }
+
+    pub fn incref(self: *LinkPool, id: IdPayload) LinkPoolError!void {
+        const unpacked = unpackId(id);
+        if (unpacked.slot_index >= self.num_slots) return LinkPoolError.InvalidId;
+
+        const p = self.slotPtr(unpacked.slot_index);
+        const header_ptr = slotHeaderPtr(p);
+
+        if (header_ptr.generation != unpacked.generation) {
+            return LinkPoolError.WrongGeneration;
+        }
+
+        const old_refcount = header_ptr.refcount;
+        header_ptr.refcount +%= 1;
+
+        if (old_refcount == 0) {
+            const live_url = try self.get(id);
+            try self.internLiveId(id, live_url);
+        }
+    }
+
+    pub fn decref(self: *LinkPool, id: IdPayload) LinkPoolError!void {
+        const unpacked = unpackId(id);
+        if (unpacked.slot_index >= self.num_slots) return LinkPoolError.InvalidId;
+
+        const p = self.slotPtr(unpacked.slot_index);
+        const header_ptr = slotHeaderPtr(p);
+
+        if (header_ptr.refcount == 0) return LinkPoolError.InvalidId;
+        if (header_ptr.generation != unpacked.generation) return LinkPoolError.WrongGeneration;
+
+        if (header_ptr.refcount == 1) {
+            const live_url = try self.get(id);
+            self.removeInternedLiveId(live_url, id);
+        }
+
+        header_ptr.refcount -%= 1;
+
+        if (header_ptr.refcount == 0) {
+            if (header_ptr.generation == GEN_MASK) {
+                header_ptr.generation = RETIRED_GENERATION;
+                self.retired_slot_count += 1;
+            } else {
+                try self.free_list.append(self.allocator, unpacked.slot_index);
+            }
+        }
+    }
+
+    pub fn get(self: *LinkPool, id: IdPayload) LinkPoolError![]const u8 {
+        const unpacked = unpackId(id);
+        if (unpacked.slot_index >= self.num_slots) return LinkPoolError.InvalidId;
+
+        const p = self.slotPtr(unpacked.slot_index);
+        const header_ptr = slotHeaderPtr(p);
+
+        if (header_ptr.generation != unpacked.generation) return LinkPoolError.WrongGeneration;
+
+        const data_ptr = @as([*]u8, @ptrCast(p)) + @sizeOf(SlotHeader);
+        return data_ptr[0..header_ptr.len];
+    }
+
+    pub fn getRefcount(self: *LinkPool, id: IdPayload) LinkPoolError!u32 {
+        const unpacked = unpackId(id);
+        if (unpacked.slot_index >= self.num_slots) return LinkPoolError.InvalidId;
+
+        const p = self.slotPtr(unpacked.slot_index);
+        const header_ptr = slotHeaderPtr(p);
+
+        if (header_ptr.generation != unpacked.generation) return LinkPoolError.WrongGeneration;
+
+        return header_ptr.refcount;
+    }
+
+    pub fn getTotalSlots(self: *const LinkPool) u64 {
+        return self.num_slots;
+    }
+
+    pub fn getFreeSlotCount(self: *const LinkPool) u64 {
+        return self.free_list.items.len;
+    }
+
+    pub fn getLiveSlotCount(self: *const LinkPool) u64 {
+        return self.num_slots - @as(u32, @intCast(self.free_list.items.len)) - self.retired_slot_count;
+    }
+};
+
+/// Track link usage per buffer with per-cell refcounting
+pub const LinkTracker = struct {
+    pool: *LinkPool,
+    used_ids: std.AutoHashMap(u32, u32), // id -> cell_count
+
+    pub fn init(allocator: std.mem.Allocator, pool: *LinkPool) LinkTracker {
+        return .{
+            .pool = pool,
+            .used_ids = std.AutoHashMap(u32, u32).init(allocator),
+        };
+    }
+
+    fn decRefAll(self: *LinkTracker) void {
+        var it = self.used_ids.iterator();
+        while (it.next()) |entry| {
+            const id = entry.key_ptr.*;
+            self.pool.decref(id) catch {};
+        }
+    }
+
+    pub fn deinit(self: *LinkTracker) void {
+        self.decRefAll();
+        self.used_ids.deinit();
+        self.* = undefined;
+    }
+
+    pub fn clear(self: *LinkTracker) void {
+        self.decRefAll();
+        self.used_ids.clearRetainingCapacity();
+    }
+
+    pub fn addCellRef(self: *LinkTracker, id: u32) void {
+        const res = self.used_ids.getOrPut(id) catch |err| {
+            std.debug.panic("LinkTracker.addCellRef getOrPut failed: {}\n", .{err});
+        };
+        if (!res.found_existing) {
+            // First time seeing this ID - try to incref in pool
+            self.pool.incref(id) catch {
+                // Invalid ID (not allocated in pool) - silently ignore
+                // This can happen with garbage in attribute bits
+                return;
+            };
+            res.value_ptr.* = 1;
+        } else {
+            res.value_ptr.* += 1;
+        }
+    }
+
+    pub fn removeCellRef(self: *LinkTracker, id: u32) void {
+        if (self.used_ids.getPtr(id)) |count_ptr| {
+            if (count_ptr.* > 0) {
+                count_ptr.* -= 1;
+                if (count_ptr.* == 0) {
+                    _ = self.used_ids.remove(id);
+                    self.pool.decref(id) catch {};
+                }
+            }
+        }
+    }
+
+    pub fn hasAny(self: *const LinkTracker) bool {
+        return self.used_ids.count() > 0;
+    }
+
+    pub fn getLinkCount(self: *const LinkTracker) u32 {
+        return @intCast(self.used_ids.count());
+    }
+};
+
+var GLOBAL_LINK_POOL: ?LinkPool = null;
+
+pub fn initGlobalLinkPool(allocator: std.mem.Allocator) *LinkPool {
+    if (GLOBAL_LINK_POOL == null) {
+        GLOBAL_LINK_POOL = LinkPool.init(allocator);
+    }
+    return &GLOBAL_LINK_POOL.?;
+}
+
+pub fn deinitGlobalLinkPool() void {
+    if (GLOBAL_LINK_POOL) |*p| {
+        p.deinit();
+        GLOBAL_LINK_POOL = null;
+    }
+}

package/src/zig/logger.zig

@@ -0,0 +1,43 @@
+const std = @import("std");
+
+pub const LogLevel = enum(u8) {
+    err = 0,
+    warn = 1,
+    info = 2,
+    debug = 3,
+};
+
+var global_log_callback: ?*const fn (level: u8, msgPtr: [*]const u8, msgLen: u32) callconv(.c) void = null;
+
+pub fn setLogCallback(callback: ?*const fn (level: u8, msgPtr: [*]const u8, msgLen: u32) callconv(.c) void) void {
+    global_log_callback = callback;
+}
+
+// Helper function to log messages - can be used directly throughout the codebase
+pub fn logMessage(level: LogLevel, comptime format: []const u8, args: anytype) void {
+    if (global_log_callback) |callback| {
+        var buf: [4096]u8 = undefined;
+        const msg = std.fmt.bufPrint(&buf, format, args) catch {
+            const fallback = "Log formatting failed";
+            callback(@intFromEnum(LogLevel.err), fallback.ptr, std.math.cast(u32, fallback.len) orelse return);
+            return;
+        };
+        callback(@intFromEnum(level), msg.ptr, std.math.cast(u32, msg.len) orelse return);
+    }
+}
+
+pub fn err(comptime format: []const u8, args: anytype) void {
+    logMessage(.err, format, args);
+}
+
+pub fn warn(comptime format: []const u8, args: anytype) void {
+    logMessage(.warn, format, args);
+}
+
+pub fn info(comptime format: []const u8, args: anytype) void {
+    logMessage(.info, format, args);
+}
+
+pub fn debug(comptime format: []const u8, args: anytype) void {
+    logMessage(.debug, format, args);
+}

package/src/zig/mem-registry.zig

@@ -0,0 +1,126 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+pub const MemRegistryError = error{
+    OutOfMemory,
+    InvalidMemId,
+};
+
+/// Memory buffer reference in the registry
+pub const MemBuffer = struct {
+    data: []const u8,
+    owned: bool,
+    active: bool, // Track if slot is in use
+};
+
+/// Registry for multiple memory buffers
+pub const MemRegistry = struct {
+    buffers: std.ArrayListUnmanaged(MemBuffer),
+    free_slots: std.ArrayListUnmanaged(u8), // Track free slot indices
+    allocator: Allocator,
+
+    pub fn init(allocator: Allocator) MemRegistry {
+        return .{
+            .buffers = .{},
+            .free_slots = .{},
+            .allocator = allocator,
+        };
+    }
+
+    pub fn deinit(self: *MemRegistry) void {
+        for (self.buffers.items) |mem_buf| {
+            if (mem_buf.active and mem_buf.owned) {
+                self.allocator.free(mem_buf.data);
+            }
+        }
+        self.buffers.deinit(self.allocator);
+        self.free_slots.deinit(self.allocator);
+        self.* = undefined;
+    }
+
+    pub fn register(self: *MemRegistry, data: []const u8, owned: bool) MemRegistryError!u8 {
+        // Try to reuse a free slot first
+        if (self.free_slots.items.len > 0) {
+            const id = self.free_slots.items[self.free_slots.items.len - 1];
+            _ = self.free_slots.pop();
+            self.buffers.items[id] = MemBuffer{
+                .data = data,
+                .owned = owned,
+                .active = true,
+            };
+            return id;
+        }
+
+        // No free slots, allocate a new one
+        if (self.buffers.items.len >= 255) {
+            return MemRegistryError.OutOfMemory;
+        }
+        const id: u8 = @intCast(self.buffers.items.len);
+        try self.buffers.append(self.allocator, .{
+            .data = data,
+            .owned = owned,
+            .active = true,
+        });
+        return id;
+    }
+
+    pub fn get(self: *const MemRegistry, id: u8) ?[]const u8 {
+        if (id >= self.buffers.items.len) return null;
+        const buf = self.buffers.items[id];
+        if (!buf.active) return null;
+        return buf.data;
+    }
+
+    pub fn replace(self: *MemRegistry, id: u8, data: []const u8, owned: bool) MemRegistryError!void {
+        if (id >= self.buffers.items.len) return MemRegistryError.InvalidMemId;
+        const prev = self.buffers.items[id];
+        if (!prev.active) return MemRegistryError.InvalidMemId;
+        if (prev.owned) {
+            self.allocator.free(prev.data);
+        }
+        self.buffers.items[id] = .{ .data = data, .owned = owned, .active = true };
+    }
+
+    pub fn unregister(self: *MemRegistry, id: u8) MemRegistryError!void {
+        if (id >= self.buffers.items.len) return MemRegistryError.InvalidMemId;
+        var buf = &self.buffers.items[id];
+        if (!buf.active) return MemRegistryError.InvalidMemId;
+
+        // Free owned memory
+        if (buf.owned) {
+            self.allocator.free(buf.data);
+        }
+
+        // Mark slot as inactive
+        buf.active = false;
+        buf.data = &[_]u8{};
+        buf.owned = false;
+
+        // Add to free slots list
+        try self.free_slots.append(self.allocator, id);
+    }
+
+    pub fn clear(self: *MemRegistry) void {
+        for (self.buffers.items) |mem_buf| {
+            if (mem_buf.active and mem_buf.owned) {
+                self.allocator.free(mem_buf.data);
+            }
+        }
+        self.buffers.clearRetainingCapacity();
+        self.free_slots.clearRetainingCapacity();
+    }
+
+    pub fn getUsedSlots(self: *const MemRegistry) usize {
+        // Count only active slots
+        var count: usize = 0;
+        for (self.buffers.items) |buf| {
+            if (buf.active) count += 1;
+        }
+        return count;
+    }
+
+    pub fn getFreeSlots(self: *const MemRegistry) usize {
+        // Total capacity (255) minus buffers allocated plus explicitly freed slots
+        return 255 - self.buffers.items.len + self.free_slots.items.len;
+    }
+};

package/src/zig/miniaudio_shim.c

@@ -0,0 +1,21 @@
+#define MINIAUDIO_IMPLEMENTATION
+
+#if defined(__linux__)
+#define MA_ENABLE_ONLY_SPECIFIC_BACKENDS
+#define MA_ENABLE_ALSA
+#define MA_ENABLE_PULSEAUDIO
+#endif
+
+#if defined(__APPLE__)
+#define MA_ENABLE_ONLY_SPECIFIC_BACKENDS
+#define MA_ENABLE_COREAUDIO
+#endif
+
+#if defined(_WIN32)
+#define MA_ENABLE_ONLY_SPECIFIC_BACKENDS
+#define MA_ENABLE_WASAPI
+#define MA_ENABLE_DSOUND
+#define MA_ENABLE_WINMM
+#endif
+
+#include "vendor/miniaudio/miniaudio.h"

package/src/zig/native-renderable.zig

@@ -0,0 +1,112 @@
+const std = @import("std");
+
+const editor_view = @import("editor-view.zig");
+const native_yoga = @import("yoga.zig");
+const text_buffer_view = @import("text-buffer-view.zig");
+
+pub const MeasureTargetKind = enum(u32) {
+    none = 0,
+    text_buffer_view = 1,
+    editor_view = 2,
+};
+
+// Generic measure targets keep Yoga independent of concrete renderable types.
+// Add target kinds here instead of adding type-specific Yoga APIs.
+pub const MeasureTarget = union(MeasureTargetKind) {
+    none,
+    text_buffer_view: *text_buffer_view.UnifiedTextBufferView,
+    editor_view: *editor_view.EditorView,
+};
+
+pub const NativeRenderable = struct {
+    // Borrowed during the migration to native-backed renderables. Today JS owns
+    // the Renderable tree and Yoga nodes; this native object only routes hot
+    // measurement without crossing back into JS. Long term, NativeRenderable
+    // should back every Renderable and own the Yoga node directly.
+    yoga_node: native_yoga.YGNodeRef = null,
+    measure_target: MeasureTarget = .none,
+
+    pub fn deinit(self: *NativeRenderable) void {
+        self.clearMeasureTarget();
+        self.yoga_node = null;
+        self.* = undefined;
+    }
+
+    pub fn attachYogaNode(self: *NativeRenderable, node: native_yoga.YGNodeRef) void {
+        if (self.yoga_node != null and self.yoga_node != node) {
+            native_yoga.yogaNodeSetNativeMeasureFunc(self.yoga_node, null, null);
+        }
+        self.yoga_node = node;
+        self.applyMeasureTarget();
+    }
+
+    pub fn setMeasureTarget(self: *NativeRenderable, target: MeasureTarget) void {
+        self.measure_target = target;
+        self.applyMeasureTarget();
+    }
+
+    pub fn clearMeasureTarget(self: *NativeRenderable) void {
+        if (self.yoga_node != null) {
+            native_yoga.yogaNodeSetNativeMeasureFunc(self.yoga_node, null, null);
+        }
+        self.measure_target = .none;
+    }
+
+    fn applyMeasureTarget(self: *NativeRenderable) void {
+        if (self.yoga_node == null) return;
+        switch (self.measure_target) {
+            .none => native_yoga.yogaNodeSetNativeMeasureFunc(self.yoga_node, null, null),
+            else => native_yoga.yogaNodeSetNativeMeasureFunc(self.yoga_node, self, &NativeRenderable.measure),
+        }
+    }
+
+    fn measure(target: ?*anyopaque, width: f32, width_mode: u32, height: f32, height_mode: u32) callconv(.c) native_yoga.ExternalYogaSize {
+        _ = height_mode;
+        const self: *NativeRenderable = @ptrCast(@alignCast(target orelse return .{ .width = std.math.nan(f32), .height = std.math.nan(f32) }));
+        const effective_width = normalizeYogaMeasureWidthInput(width, width_mode);
+        const effective_height = normalizeYogaMeasureHeightInput(height);
+        const measure_width = floorToU32(effective_width);
+        const measure_height = floorToU32(effective_height);
+        const result = self.measureTarget(measure_width, measure_height) orelse return .{ .width = 1, .height = 1 };
+
+        var measured_width: f32 = @floatFromInt(@max(@as(u32, 1), result.width_cols_max));
+        var measured_height: f32 = @floatFromInt(@max(@as(u32, 1), result.line_count));
+
+        if (width_mode == @intFromEnum(native_yoga.YogaMeasureMode.at_most) and self.yoga_node != null and !isYogaNodeAbsolute(self.yoga_node)) {
+            measured_width = @min(effective_width, measured_width);
+            measured_height = @min(effective_height, measured_height);
+        }
+
+        return .{ .width = measured_width, .height = measured_height };
+    }
+
+    fn measureTarget(self: *NativeRenderable, width: u32, height: u32) ?text_buffer_view.MeasureResult {
+        return switch (self.measure_target) {
+            .none => null,
+            .text_buffer_view => |view| view.measureForDimensions(width, height) catch null,
+            .editor_view => |view| view.getTextBufferView().measureForDimensions(width, height) catch null,
+        };
+    }
+};
+
+pub fn normalizeYogaMeasureWidthInput(value: f32, width_mode: u32) f32 {
+    if (width_mode == @intFromEnum(native_yoga.YogaMeasureMode.undefined) or std.math.isNan(value)) return 0;
+    return value;
+}
+
+pub fn normalizeYogaMeasureHeightInput(value: f32) f32 {
+    if (std.math.isNan(value)) return 1;
+    return value;
+}
+
+fn floorToU32(value: f32) u32 {
+    if (!std.math.isFinite(value) or value <= 0) return 0;
+    const floored = @floor(value);
+    if (floored >= @as(f32, @floatFromInt(std.math.maxInt(u32)))) return std.math.maxInt(u32);
+    return @intFromFloat(floored);
+}
+
+fn isYogaNodeAbsolute(node: native_yoga.YGNodeRef) bool {
+    return native_yoga.yogaNodeStyleGetEnum(node, @intFromEnum(native_yoga.YogaEnumKind.position_type)) ==
+        @intFromEnum(native_yoga.YogaPositionType.absolute);
+}

package/src/zig/native-span-feed-bench-lib.zig

@@ -0,0 +1,7 @@
+const lib = @import("lib.zig");
+const bench = @import("bench/native-span-feed_bench.zig");
+
+comptime {
+    _ = lib;
+    _ = bench;
+}