@xincli/opentui-core 0.4.6 → 0.4.7

package/src/zig/link.zig

@@ -1,349 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,21 +0,0 @@
-#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

@@ -1,112 +0,0 @@
-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

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