rufio 0.33.0 → 0.40.0

data/lib/rufio/text_utils.rb

@@ -18,10 +18,12 @@ module Rufio
     # Line break constants
     BREAK_POINT_THRESHOLD = 0.5  # Break after 50% of max_width
 
-    # Calculate display width of a string
-    # Full-width characters (Japanese, etc.) count as 2, half-width as 1
-    def display_width(string)
-      string.each_char.map do |char|
+    # Character width cache (memo化)
+    @char_width_cache = {}
+
+    # Calculate width for a single character with caching
+    def char_width(char)
+      @char_width_cache[char] ||= begin
         case char
         when /[\u3000-\u303F\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF\uFF00-\uFFEF\u2500-\u257F\u2580-\u259F]/
           FULLWIDTH_CHAR_WIDTH  # Japanese characters (hiragana, katakana, kanji, full-width symbols, box drawing, block elements)
@@ -30,7 +32,17 @@ module Rufio
         else
           char.bytesize > MULTIBYTE_THRESHOLD ? FULLWIDTH_CHAR_WIDTH : HALFWIDTH_CHAR_WIDTH
         end
-      end.sum
+      end
+    end
+
+    # Calculate display width of a string
+    # Full-width characters (Japanese, etc.) count as 2, half-width as 1
+    def display_width(string)
+      width = 0
+      string.each_char do |char|
+        width += char_width(char)
+      end
+      width
     end
 
     # Truncate string to fit within max_width
@@ -44,11 +56,11 @@ module Rufio
         target_width = max_width - ELLIPSIS_MIN_WIDTH
 
         string.each_char do |char|
-          char_width = display_width(char)
-          break if current_width + char_width > target_width
+          cw = char_width(char)
+          break if current_width + cw > target_width
 
           result += char
-          current_width += char_width
+          current_width += cw
         end
 
         result + ELLIPSIS
@@ -58,11 +70,11 @@ module Rufio
         current_width = 0
 
         string.each_char do |char|
-          char_width = display_width(char)
-          break if current_width + char_width > max_width
+          cw = char_width(char)
+          break if current_width + cw > max_width
 
           result += char
-          current_width += char_width
+          current_width += cw
         end
 
         result
@@ -89,10 +101,10 @@ module Rufio
       punct_break_point = nil
 
       line.each_char.with_index do |char, index|
-        char_width = display_width(char)
-        break if current_width + char_width > max_width
+        cw = char_width(char)
+        break if current_width + cw > max_width
 
-        current_width += char_width
+        current_width += cw
         best_break_point = index + 1
 
         # Record break point at space
@@ -134,16 +146,16 @@ module Rufio
         current_width = 0
 
         line.each_char do |char|
-          char_width = display_width(char)
+          cw = char_width(char)
 
-          if current_width + char_width > max_width
+          if current_width + cw > max_width
             # Start a new line
             wrapped << current_line.join
             current_line = [char]
-            current_width = char_width
+            current_width = cw
           else
             current_line << char
-            current_width += char_width
+            current_width += cw
           end
         end
 

data/lib/rufio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rufio
-  VERSION = '0.33.0'
+  VERSION = '0.40.0'
 end

data/lib/rufio.rb

@@ -33,8 +33,12 @@ require_relative "rufio/shell_command_completion"
 require_relative "rufio/command_logger"
 require_relative "rufio/background_command_executor"
 require_relative "rufio/native_scanner"
-require_relative "rufio/native_scanner_magnus"
 require_relative "rufio/native_scanner_zig"
+require_relative "rufio/async_scanner_promise"
+require_relative "rufio/async_scanner_fiber"
+require_relative "rufio/parallel_scanner"
+require_relative "rufio/screen"
+require_relative "rufio/renderer"
 
 # プロジェクトモード
 require_relative "rufio/project_mode"

data/lib_zig/rufio_native/Makefile

@@ -7,13 +7,14 @@ ZIG := zig
 RUBY_INCLUDE := $(shell $(RUBY) -e "puts RbConfig::CONFIG['rubyhdrdir']")
 RUBY_ARCH_INCLUDE := $(shell $(RUBY) -e "puts RbConfig::CONFIG['rubyarchhdrdir']")
 RUBY_LIB_DIR := $(shell $(RUBY) -e "puts RbConfig::CONFIG['libdir']")
+RUBY_VERSION := $(shell $(RUBY) -e "puts RbConfig::CONFIG['MAJOR'] + '.' + RbConfig::CONFIG['MINOR']")
 
 # コンパイルフラグ
 ZIG_FLAGS := -O ReleaseFast -dynamic -lc
 ZIG_FLAGS += -I$(RUBY_INCLUDE)
 ZIG_FLAGS += -I$(RUBY_ARCH_INCLUDE)
 ZIG_FLAGS += -L$(RUBY_LIB_DIR)
-ZIG_FLAGS += -lruby.3.4
+ZIG_FLAGS += -lruby.$(RUBY_VERSION)
 
 # ターゲット
 TARGET := librufio_zig.dylib

data/lib_zig/rufio_native/src/main.zig

@@ -1,167 +1,378 @@
 const std = @import("std");
 const c = @cImport({
-    @cInclude("ruby.h");
     @cInclude("dirent.h");
     @cInclude("sys/stat.h");
     @cInclude("string.h");
-    @cInclude("time.h");
+    @cInclude("stdlib.h");
+    @cInclude("pthread.h");
 });
 
-/// ディレクトリエントリ情報
+/// スキャン状態
+pub const ScanState = enum(u8) {
+    idle = 0,
+    scanning = 1,
+    done = 2,
+    cancelled = 3,
+    failed = 4,
+};
+
+/// ディレクトリエントリ情報（内部保持用）
 const DirEntry = struct {
-    name: []const u8,
+    name: []u8,
     is_dir: bool,
     size: u64,
     mtime: i64,
     executable: bool,
     hidden: bool,
+
+    fn deinit(self: *DirEntry) void {
+        c.free(self.name.ptr);
+    }
 };
 
-/// ディレクトリをスキャンしてRuby配列を返す
-fn scanDirectory(self: c.VALUE, path_value: c.VALUE) callconv(.c) c.VALUE {
-    _ = self;
-
-    // パス文字列を取得
-    var mutable_path = path_value;
-    const path_str = c.rb_string_value_cstr(@ptrCast(&mutable_path));
-    const path_len = c.strlen(path_str);
-    const path = path_str[0..path_len];
-
-    // ディレクトリを開く
-    const dir = c.opendir(path_str) orelse {
-        c.rb_raise(c.rb_eRuntimeError, "Failed to open directory");
-        return c.Qnil;
-    };
-    defer _ = c.closedir(dir);
-
-    // Ruby配列を作成
-    const ary = c.rb_ary_new();
-
-    // ディレクトリエントリを読み取り
-    while (c.readdir(dir)) |entry| {
-        const name_ptr = @as([*:0]const u8, @ptrCast(&entry.*.d_name));
-        const name_len = c.strlen(name_ptr);
-        const name = name_ptr[0..name_len];
-
-        // "." と ".." をスキップ
-        if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) {
-            continue;
+/// 非同期スキャナーコア（状態を保持）
+const AsyncScanner = struct {
+    entries: []DirEntry,
+    capacity: usize,
+    count: usize,
+    state: ScanState,
+    progress: usize,
+    total_estimate: usize,
+    mutex: c.pthread_mutex_t,
+    path_copy: ?[*:0]u8,
+    max_entries: usize,
+    thread: c.pthread_t,
+    thread_started: bool,
+
+    fn init() !*AsyncScanner {
+        const self = @as(?*AsyncScanner, @ptrCast(@alignCast(c.malloc(@sizeOf(AsyncScanner))))) orelse return error.OutOfMemory;
+
+        self.*.capacity = 64;
+        const entries_size = self.*.capacity * @sizeOf(DirEntry);
+        const entries_ptr = c.malloc(entries_size) orelse {
+            c.free(self);
+            return error.OutOfMemory;
+        };
+        self.*.entries = @as([*]DirEntry, @ptrCast(@alignCast(entries_ptr)))[0..self.*.capacity];
+        self.*.count = 0;
+        self.*.state = .idle;
+        self.*.progress = 0;
+        self.*.total_estimate = 0;
+        self.*.path_copy = null;
+        self.*.max_entries = 0;
+        self.*.thread_started = false;
+
+        // mutex初期化
+        _ = c.pthread_mutex_init(&self.*.mutex, null);
+
+        return self;
+    }
+
+    fn deinit(self: *AsyncScanner) void {
+        // スレッドが実行中なら待機
+        if (self.thread_started) {
+            _ = c.pthread_join(self.thread, null);
         }
 
-        // フルパスを構築
-        var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-        const full_path = std.fmt.bufPrintZ(&path_buf, "{s}/{s}", .{ path, name }) catch {
-            continue;
-        };
+        // 各エントリの名前を解放
+        for (self.entries[0..self.count]) |*entry| {
+            entry.deinit();
+        }
 
-        // ファイル情報を取得
-        var stat_buf: c.struct_stat = undefined;
-        if (c.lstat(full_path.ptr, &stat_buf) != 0) {
-            continue;
+        // パスのコピーを解放
+        if (self.path_copy) |path| {
+            c.free(path);
         }
 
-        // ディレクトリかどうか
-        const is_dir = (stat_buf.st_mode & c.S_IFMT) == c.S_IFDIR;
+        // エントリ配列を解放
+        c.free(self.entries.ptr);
 
-        // 実行可能かどうか
-        const executable = (stat_buf.st_mode & c.S_IXUSR) != 0;
+        // mutex破棄
+        _ = c.pthread_mutex_destroy(&self.mutex);
 
-        // 隠しファイルかどうか
-        const hidden = name[0] == '.';
+        // 自身を解放
+        c.free(self);
+    }
 
-        // Rubyハッシュを作成
-        const hash = c.rb_hash_new();
+    fn clear(self: *AsyncScanner) void {
+        // 既存のエントリをクリア
+        for (self.entries[0..self.count]) |*entry| {
+            entry.deinit();
+        }
+        self.count = 0;
+        self.progress = 0;
+        self.total_estimate = 0;
+    }
 
-        // ハッシュにキーと値を設定
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("name")), c.rb_str_new(name.ptr, @intCast(name.len)));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("is_dir")), if (is_dir) c.Qtrue else c.Qfalse);
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("size")), c.ULL2NUM(@as(c_ulonglong, @intCast(stat_buf.st_size))));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("mtime")), c.LL2NUM(@as(c_longlong, @intCast(stat_buf.st_mtimespec.tv_sec))));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("executable")), if (executable) c.Qtrue else c.Qfalse);
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("hidden")), if (hidden) c.Qtrue else c.Qfalse);
+    fn ensureCapacity(self: *AsyncScanner, needed: usize) !void {
+        if (needed <= self.capacity) return;
 
-        // 配列に追加
-        _ = c.rb_ary_push(ary, hash);
+        const new_capacity = @max(needed, self.capacity * 2);
+        const new_size = new_capacity * @sizeOf(DirEntry);
+        const new_ptr = c.realloc(self.entries.ptr, new_size) orelse return error.OutOfMemory;
+        self.entries = @as([*]DirEntry, @ptrCast(@alignCast(new_ptr)))[0..new_capacity];
+        self.capacity = new_capacity;
     }
 
-    return ary;
-}
+    fn isCancelled(self: *AsyncScanner) bool {
+        _ = c.pthread_mutex_lock(&self.mutex);
+        defer _ = c.pthread_mutex_unlock(&self.mutex);
+        return self.state == .cancelled;
+    }
 
-/// 高速スキャン（エントリ数制限付き）
-fn scanDirectoryFast(self: c.VALUE, path_value: c.VALUE, max_entries_value: c.VALUE) callconv(.c) c.VALUE {
-    _ = self;
+    fn setState(self: *AsyncScanner, new_state: ScanState) void {
+        _ = c.pthread_mutex_lock(&self.mutex);
+        defer _ = c.pthread_mutex_unlock(&self.mutex);
+        self.state = new_state;
+    }
+
+    fn scan(self: *AsyncScanner, path: [*:0]const u8, max_entries: usize) !void {
+        // クリア
+        self.clear();
+
+        const dir = c.opendir(path) orelse return error.CannotOpenDir;
+        defer _ = c.closedir(dir);
+
+        const path_len = c.strlen(path);
+        const path_slice = path[0..path_len];
+
+        while (c.readdir(dir)) |entry| {
+            // キャンセルチェック
+            if (self.isCancelled()) {
+                return error.Cancelled;
+            }
+
+            // エントリ数制限チェック
+            if (max_entries > 0 and self.count >= max_entries) break;
+
+            const name_ptr = @as([*:0]const u8, @ptrCast(&entry.*.d_name));
+            const name_len = c.strlen(name_ptr);
+            const name_slice = name_ptr[0..name_len];
+
+            // "." と ".." をスキップ
+            if (std.mem.eql(u8, name_slice, ".") or std.mem.eql(u8, name_slice, "..")) {
+                continue;
+            }
+
+            // 容量確保
+            try self.ensureCapacity(self.count + 1);
+
+            // フルパスを構築
+            var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+            const full_path = std.fmt.bufPrintZ(&path_buf, "{s}/{s}", .{ path_slice, name_slice }) catch continue;
+
+            // ファイル情報を取得
+            var stat_buf: c.struct_stat = undefined;
+            if (c.lstat(full_path.ptr, &stat_buf) != 0) {
+                continue;
+            }
+
+            // 名前をコピー
+            const name_copy_ptr = c.malloc(name_len + 1) orelse return error.OutOfMemory;
+            const name_copy_bytes = @as([*]u8, @ptrCast(@alignCast(name_copy_ptr)));
+            const name_copy = name_copy_bytes[0..name_len];
+            @memcpy(name_copy, name_slice);
+            name_copy_bytes[name_len] = 0;
+
+            // エントリを追加
+            self.entries[self.count] = DirEntry{
+                .name = name_copy,
+                .is_dir = (stat_buf.st_mode & c.S_IFMT) == c.S_IFDIR,
+                .size = @intCast(stat_buf.st_size),
+                .mtime = @intCast(stat_buf.st_mtimespec.tv_sec),
+                .executable = (stat_buf.st_mode & c.S_IXUSR) != 0,
+                .hidden = name_slice[0] == '.',
+            };
+            self.count += 1;
+
+            // 進捗更新
+            _ = c.pthread_mutex_lock(&self.mutex);
+            self.progress = self.count;
+            _ = c.pthread_mutex_unlock(&self.mutex);
+        }
+    }
 
-    const max_entries = @as(usize, @intCast(c.NUM2INT(max_entries_value)));
-    var mutable_path = path_value;
-    const path_str = c.rb_string_value_cstr(@ptrCast(&mutable_path));
-    const path_len = c.strlen(path_str);
-    const path = path_str[0..path_len];
+    fn scanAsync(self: *AsyncScanner, path: [*:0]const u8, max_entries: usize) !void {
+        _ = c.pthread_mutex_lock(&self.mutex);
+        defer _ = c.pthread_mutex_unlock(&self.mutex);
 
-    const dir = c.opendir(path_str) orelse {
-        c.rb_raise(c.rb_eRuntimeError, "Failed to open directory");
-        return c.Qnil;
-    };
-    defer _ = c.closedir(dir);
+        if (self.state == .scanning) {
+            return error.AlreadyScanning;
+        }
 
-    const ary = c.rb_ary_new();
-    var count: usize = 0;
+        // パスをコピー
+        const path_len = c.strlen(path);
+        const path_copy_ptr = c.malloc(path_len + 1) orelse return error.OutOfMemory;
+        const path_copy_bytes = @as([*:0]u8, @ptrCast(@alignCast(path_copy_ptr)));
+        @memcpy(path_copy_bytes[0..path_len], path[0..path_len]);
+        path_copy_bytes[path_len] = 0;
 
-    while (c.readdir(dir)) |entry| {
-        if (count >= max_entries) break;
+        // 古いパスを解放
+        if (self.path_copy) |old_path| {
+            c.free(old_path);
+        }
 
-        const name_ptr = @as([*:0]const u8, @ptrCast(&entry.*.d_name));
-        const name_len = c.strlen(name_ptr);
-        const name = name_ptr[0..name_len];
+        self.path_copy = path_copy_bytes;
+        self.max_entries = max_entries;
+        self.state = .scanning;
 
-        if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) {
-            continue;
+        // スレッド開始
+        const result = c.pthread_create(&self.thread, null, scanWorkerEntry, self);
+        if (result != 0) {
+            self.state = .failed;
+            return error.ThreadCreateFailed;
         }
+        self.thread_started = true;
+    }
 
-        var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-        const full_path = std.fmt.bufPrintZ(&path_buf, "{s}/{s}", .{ path, name }) catch {
-            continue;
+    fn scanWorker(self: *AsyncScanner) void {
+        const path = self.path_copy orelse {
+            self.setState(.failed);
+            return;
         };
 
-        var stat_buf: c.struct_stat = undefined;
-        if (c.lstat(full_path.ptr, &stat_buf) != 0) {
-            continue;
-        }
+        self.scan(path, self.max_entries) catch |err| {
+            // キャンセルエラーの場合は状態を変更しない（既にcancelledになっている）
+            if (err == error.Cancelled) {
+                return;
+            }
+            self.setState(.failed);
+            return;
+        };
+
+        self.setState(.done);
+    }
+};
+
+// スレッドエントリポイント
+fn scanWorkerEntry(arg: ?*anyopaque) callconv(.c) ?*anyopaque {
+    const scanner = @as(*AsyncScanner, @ptrCast(@alignCast(arg)));
+    scanner.scanWorker();
+    return null;
+}
+
+// ============================================================
+// ABI Boundary: Ruby ABI非依存・ハンドルベース
+// ============================================================
 
-        const is_dir = (stat_buf.st_mode & c.S_IFMT) == c.S_IFDIR;
-        const executable = (stat_buf.st_mode & c.S_IXUSR) != 0;
-        const hidden = name[0] == '.';
+/// 非同期スキャナーを作成（ハンドル返却）
+export fn core_async_create() u64 {
+    const scanner = AsyncScanner.init() catch return 0;
+    return @intFromPtr(scanner);
+}
+
+/// 非同期スキャン開始
+export fn core_async_scan(handle: u64, path: [*:0]const u8) i32 {
+    if (handle == 0) return -1;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    scanner.scanAsync(path, 0) catch return -1;
+    return 0;
+}
+
+/// 高速スキャン（エントリ数制限付き）
+export fn core_async_scan_fast(handle: u64, path: [*:0]const u8, max_entries: usize) i32 {
+    if (handle == 0) return -1;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    scanner.scanAsync(path, max_entries) catch return -1;
+    return 0;
+}
 
-        const hash = c.rb_hash_new();
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("name")), c.rb_str_new(name.ptr, @intCast(name.len)));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("is_dir")), if (is_dir) c.Qtrue else c.Qfalse);
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("size")), c.ULL2NUM(@as(c_ulonglong, @intCast(stat_buf.st_size))));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("mtime")), c.LL2NUM(@as(c_longlong, @intCast(stat_buf.st_mtimespec.tv_sec))));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("executable")), if (executable) c.Qtrue else c.Qfalse);
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("hidden")), if (hidden) c.Qtrue else c.Qfalse);
+/// 状態取得
+export fn core_async_get_state(handle: u64) u8 {
+    if (handle == 0) return @intFromEnum(ScanState.failed);
 
-        _ = c.rb_ary_push(ary, hash);
-        count += 1;
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+    return @intFromEnum(scanner.state);
+}
+
+/// 進捗取得
+export fn core_async_get_progress(handle: u64, current: *usize, total: *usize) void {
+    if (handle == 0) {
+        current.* = 0;
+        total.* = 0;
+        return;
     }
 
-    return ary;
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+
+    current.* = scanner.progress;
+    total.* = scanner.total_estimate;
 }
 
-/// バージョン情報
-fn getVersion(_: c.VALUE) callconv(.c) c.VALUE {
-    const version = "1.0.0-zig";
-    return c.rb_str_new(version.ptr, @intCast(version.len));
+/// キャンセル
+export fn core_async_cancel(handle: u64) void {
+    if (handle == 0) return;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+
+    if (scanner.state == .scanning) {
+        scanner.state = .cancelled;
+    }
 }
 
-/// Ruby拡張の初期化
-export fn Init_rufio_zig() void {
-    // Rufioモジュールを取得または作成
-    const rufio_module = c.rb_define_module("Rufio");
+/// エントリ数を取得
+export fn core_async_get_count(handle: u64) usize {
+    if (handle == 0) return 0;
 
-    // NativeScannerZigクラスを定義
-    const scanner_class = c.rb_define_class_under(rufio_module, "NativeScannerZig", c.rb_cObject);
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+    return scanner.count;
+}
+
+/// 指定インデックスのエントリ名を取得
+export fn core_async_get_name(handle: u64, index: usize, buf: [*]u8, buf_size: usize) usize {
+    if (handle == 0) return 0;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+
+    if (index >= scanner.count) return 0;
+
+    const entry = &scanner.entries[index];
+    const copy_len = @min(entry.name.len, buf_size - 1);
+    @memcpy(buf[0..copy_len], entry.name[0..copy_len]);
+    buf[copy_len] = 0;
+    return copy_len;
+}
+
+/// 指定インデックスのエントリ属性を取得
+export fn core_async_get_attrs(handle: u64, index: usize, is_dir: *u8, size: *u64, mtime: *i64, executable: *u8, hidden: *u8) i32 {
+    if (handle == 0) return -1;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
 
-    // クラスメソッドを定義
-    c.rb_define_singleton_method(scanner_class, "scan_directory", @ptrCast(&scanDirectory), 1);
-    c.rb_define_singleton_method(scanner_class, "scan_directory_fast", @ptrCast(&scanDirectoryFast), 2);
-    c.rb_define_singleton_method(scanner_class, "version", @ptrCast(&getVersion), 0);
+    if (index >= scanner.count) return -1;
+
+    const entry = &scanner.entries[index];
+    is_dir.* = if (entry.is_dir) 1 else 0;
+    size.* = entry.size;
+    mtime.* = entry.mtime;
+    executable.* = if (entry.executable) 1 else 0;
+    hidden.* = if (entry.hidden) 1 else 0;
+    return 0;
+}
+
+/// スキャナーを破棄
+export fn core_async_destroy(handle: u64) void {
+    if (handle == 0) return;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    scanner.deinit();
+}
+
+/// バージョン情報
+export fn core_async_version() [*:0]const u8 {
+    return "4.0.0-async";
 }