@visual-z/xeno 0.1.4 → 0.2.1

package/src/vendor/pi-tui/native/clipboard.h

@@ -0,0 +1,208 @@
+#ifndef PI_CLIPBOARD_H
+#define PI_CLIPBOARD_H
+
+#include "napi.h"
+#ifndef _WIN32
+#include <stdlib.h>
+#include <string.h>
+#endif
+
+typedef enum { CLIPBOARD_TEXT, CLIPBOARD_IMAGE, CLIPBOARD_WRITE, CLIPBOARD_FILES } clipboard_operation;
+// CLIPBOARD_PATHS stores concatenated, NUL-terminated UTF-8 paths in clipboard_job.data.
+typedef enum {
+    CLIPBOARD_UNAVAILABLE,
+    CLIPBOARD_EMPTY,
+    CLIPBOARD_UTF8,
+    CLIPBOARD_LATIN1,
+    CLIPBOARD_UTF16,
+    CLIPBOARD_BUFFER,
+    CLIPBOARD_PATHS
+} clipboard_format;
+
+typedef struct {
+    napi_async_work work;
+    napi_deferred deferred;
+    clipboard_operation operation;
+    clipboard_format format;
+    void* data;
+    size_t length;
+    const char* error;
+} clipboard_job;
+
+// Only this function runs on the worker thread. It must not call N-API.
+static void clipboard_execute(clipboard_job* job);
+
+static void* clipboard_alloc(size_t size) {
+#ifdef _WIN32
+    return GlobalAlloc(GPTR, size);
+#else
+    return calloc(1, size);
+#endif
+}
+
+static void clipboard_free(void* data) {
+#ifdef _WIN32
+    if (data) GlobalFree(data);
+#else
+    free(data);
+#endif
+}
+
+#ifdef PI_CLIPBOARD_WRITE
+static void clipboard_copy(clipboard_job* job, const void* data, size_t length, clipboard_format format) {
+    job->data = clipboard_alloc(length ? length : 1);
+    if (!job->data) {
+        job->error = "Out of memory";
+        return;
+    }
+#ifdef _WIN32
+    volatile uint8_t* target = job->data;
+    const volatile uint8_t* source = data;
+    for (size_t index = 0; index < length; index++) target[index] = source[index];
+#else
+    memcpy(job->data, data, length);
+#endif
+    job->length = format == CLIPBOARD_UTF16 ? length / sizeof(uint16_t) : length;
+    job->format = format;
+}
+#endif
+
+static void PI_NAPI_CALL execute_clipboard_work(napi_env env, void* data) {
+    (void)env;
+    clipboard_execute(data);
+}
+
+static int create_clipboard_paths_value(
+    napi_env env,
+    const clipboard_job* job,
+    napi_create_string_utf8_fn create_string,
+    napi_value* result
+) {
+    napi_create_array_fn create_array = (napi_create_array_fn)node_symbol("napi_create_array");
+    napi_set_element_fn set_element = (napi_set_element_fn)node_symbol("napi_set_element");
+    if (!create_array || !set_element || create_array(env, result) != 0) return 1;
+
+    const char* cursor = job->data;
+    const char* end = cursor + job->length;
+    for (uint32_t index = 0; cursor < end; index++) {
+        const char* terminator = cursor;
+        while (terminator < end && *terminator != '\0') terminator++;
+        if (terminator == end) return 1;
+
+        napi_value item = 0;
+        if (create_string(env, cursor, (size_t)(terminator - cursor), &item) != 0 ||
+            set_element(env, *result, index, item) != 0) {
+            return 1;
+        }
+        cursor = terminator + 1;
+    }
+    return 0;
+}
+
+static void PI_NAPI_CALL complete_clipboard_work(napi_env env, int status, void* data) {
+    clipboard_job* job = data;
+    napi_create_string_utf8_fn create_string = (napi_create_string_utf8_fn)node_symbol("napi_create_string_utf8");
+    napi_value result = undefined_value(env);
+    if (status != 0) job->error = "Clipboard operation cancelled";
+    if (!job->error && job->operation != CLIPBOARD_WRITE) {
+        if (job->format == CLIPBOARD_EMPTY) {
+            result = null_value(env);
+        } else if (job->format == CLIPBOARD_PATHS) {
+            status = create_clipboard_paths_value(env, job, create_string, &result);
+        } else if (job->format == CLIPBOARD_BUFFER) {
+            napi_create_buffer_copy_fn create_buffer = (napi_create_buffer_copy_fn)node_symbol("napi_create_buffer_copy");
+            status = create_buffer(env, job->length, job->data, 0, &result);
+        } else if (job->format == CLIPBOARD_UTF16) {
+            napi_create_string_utf16_fn create_utf16 = (napi_create_string_utf16_fn)node_symbol("napi_create_string_utf16");
+            status = create_utf16(env, job->data, job->length, &result);
+        } else if (job->format == CLIPBOARD_UTF8 || job->format == CLIPBOARD_LATIN1) {
+            napi_create_string_utf8_fn create_text = job->format == CLIPBOARD_LATIN1
+                ? (napi_create_string_utf8_fn)node_symbol("napi_create_string_latin1") : create_string;
+            status = create_text(env, job->data, job->length, &result);
+        }
+        if (status != 0) job->error = "Could not create clipboard value";
+    }
+    if (job->error) {
+        napi_create_error_fn create_error = (napi_create_error_fn)node_symbol("napi_create_error");
+        napi_value message;
+        create_string(env, job->error, NAPI_AUTO_LENGTH, &message);
+        create_error(env, 0, message, &result);
+    }
+    napi_settle_deferred_fn settle = (napi_settle_deferred_fn)node_symbol(
+        job->error ? "napi_reject_deferred" : "napi_resolve_deferred"
+    );
+    settle(env, job->deferred, result);
+    napi_async_work_fn delete_work = (napi_async_work_fn)node_symbol("napi_delete_async_work");
+    delete_work(env, job->work);
+    clipboard_free(job->data);
+    clipboard_free(job);
+}
+
+static napi_value queue_clipboard(napi_env env, napi_callback_info info, clipboard_operation operation) {
+    napi_create_async_work_fn create_work = (napi_create_async_work_fn)node_symbol("napi_create_async_work");
+    napi_async_work_fn queue_work = (napi_async_work_fn)node_symbol("napi_queue_async_work");
+    napi_async_work_fn delete_work = (napi_async_work_fn)node_symbol("napi_delete_async_work");
+    napi_create_promise_fn create_promise = (napi_create_promise_fn)node_symbol("napi_create_promise");
+    napi_create_string_utf8_fn create_string = (napi_create_string_utf8_fn)node_symbol("napi_create_string_utf8");
+    if (!create_work || !queue_work || !delete_work || !create_promise || !create_string) {
+        return fail(env, "Async clipboard API unavailable");
+    }
+    clipboard_job* job = clipboard_alloc(sizeof(*job));
+    if (!job) return fail(env, "Out of memory");
+    job->operation = operation;
+#ifdef PI_CLIPBOARD_WRITE
+    if (operation == CLIPBOARD_WRITE) {
+        napi_get_cb_info_fn get_info = (napi_get_cb_info_fn)node_symbol("napi_get_cb_info");
+#ifdef _WIN32
+        napi_get_value_string_utf16_fn get_string = (napi_get_value_string_utf16_fn)node_symbol("napi_get_value_string_utf16");
+        size_t unit_size = sizeof(uint16_t);
+#else
+        napi_get_value_string_utf8_fn get_string = (napi_get_value_string_utf8_fn)node_symbol("napi_get_value_string_utf8");
+        size_t unit_size = 1;
+#endif
+        size_t argc = 1;
+        napi_value argument = 0;
+        if (!get_info || !get_string || get_info(env, info, &argc, &argument, 0, 0) != 0 || argc == 0 ||
+            get_string(env, argument, 0, 0, &job->length) != 0) {
+            clipboard_free(job);
+            return fail(env, "setText requires a string");
+        }
+        job->data = job->length < SIZE_MAX / unit_size
+            ? clipboard_alloc((job->length + 1) * unit_size) : 0;
+        if (!job->data || get_string(env, argument, job->data, job->length + 1, &job->length) != 0) {
+            clipboard_free(job->data);
+            clipboard_free(job);
+            return fail(env, "Could not read clipboard text");
+        }
+    }
+#else
+    (void)info;
+#endif
+    napi_value name = 0;
+    napi_value promise = 0;
+    if (create_string(env, "pi.clipboard", NAPI_AUTO_LENGTH, &name) != 0 ||
+        create_work(env, 0, name, execute_clipboard_work, complete_clipboard_work, job, &job->work) != 0 ||
+        create_promise(env, &job->deferred, &promise) != 0 || queue_work(env, job->work) != 0) {
+        if (job->work) delete_work(env, job->work);
+        clipboard_free(job->data);
+        clipboard_free(job);
+        return fail(env, "Could not queue clipboard operation");
+    }
+    return promise;
+}
+
+static napi_value PI_NAPI_CALL get_clipboard_text(napi_env env, napi_callback_info info) {
+    return queue_clipboard(env, info, CLIPBOARD_TEXT);
+}
+
+static napi_value PI_NAPI_CALL get_clipboard_image(napi_env env, napi_callback_info info) {
+    return queue_clipboard(env, info, CLIPBOARD_IMAGE);
+}
+
+#ifdef PI_CLIPBOARD_WRITE
+static napi_value PI_NAPI_CALL set_clipboard_text(napi_env env, napi_callback_info info) {
+    return queue_clipboard(env, info, CLIPBOARD_WRITE);
+}
+#endif
+
+#endif

package/src/vendor/pi-tui/native/darwin/README.md

@@ -0,0 +1,22 @@
+# Darwin native prebuilds
+
+Provides modifier-key state and asynchronous text, image, and file-path clipboard access using AppKit.
+
+## Building
+
+On macOS, run from the repository root:
+
+```sh
+npm --prefix packages/tui run build:native:darwin
+```
+
+The build uses Apple clang and the macOS SDK found through `xcrun`. Either Intel or Apple Silicon can build both targets: arm64 (macOS 11+) and x64 (macOS 10.15+).
+
+Cross-building requires a Darwin toolchain with a macOS SDK and Mach-O linker, such as osxcross:
+
+```sh
+CC=/path/to/osxcross/clang SDKROOT=/path/to/MacOSX.sdk \
+  npm --prefix packages/tui run build:native:darwin
+```
+
+The SDK must be obtained and used under Apple's license. Plain clang or Zig alone is not sufficient.

package/src/vendor/pi-tui/native/darwin/build.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source_file="$script_dir/src/darwin-platform.m"
+
+if [[ -n "${CC:-}" ]]; then
+    compiler="$CC"
+elif [[ "$(uname -s)" == "Darwin" ]] && command -v xcrun >/dev/null 2>&1; then
+    compiler="$(xcrun --find clang)"
+else
+    compiler="clang"
+fi
+
+if ! command -v "$compiler" >/dev/null 2>&1; then
+    echo "Darwin C compiler not found: $compiler" >&2
+    exit 1
+fi
+
+sdk_flags=()
+if [[ -n "${SDKROOT:-}" ]]; then
+    if [[ ! -d "$SDKROOT" ]]; then
+        echo "SDKROOT does not exist: $SDKROOT" >&2
+        exit 1
+    fi
+    sdk_flags=(-isysroot "$SDKROOT" "-F$SDKROOT/System/Library/Frameworks")
+elif [[ "$(uname -s)" == "Darwin" ]]; then
+    sdkroot="$(xcrun --sdk macosx --show-sdk-path)"
+    sdk_flags=(-isysroot "$sdkroot" "-F$sdkroot/System/Library/Frameworks")
+fi
+
+temporary_dir="$(mktemp -d "${TMPDIR:-/tmp}/pi-tui-darwin.XXXXXX")"
+trap 'rm -rf "$temporary_dir"' EXIT
+
+build() {
+    local arch="$1"
+    local target="$2"
+    local output_dir="$script_dir/prebuilds/darwin-$arch"
+    local temporary_output="$temporary_dir/darwin-$arch/darwin-platform.node"
+
+    mkdir -p "$(dirname "$temporary_output")"
+    "$compiler" \
+        -fobjc-arc \
+        -std=c11 \
+        -Wall \
+        -Wextra \
+        -Oz \
+        -flto \
+        -fvisibility=hidden \
+        "--target=$target" \
+        "${sdk_flags[@]}" \
+        -bundle \
+        -undefined dynamic_lookup \
+        -Wl,-dead_strip \
+        -Wl,-x \
+        -framework AppKit \
+        -framework CoreGraphics \
+        -framework Foundation \
+        "$source_file" \
+        -o "$temporary_output"
+
+    mkdir -p "$output_dir"
+    install -m 755 "$temporary_output" "$output_dir/darwin-platform.node"
+    echo "Built $output_dir/darwin-platform.node"
+}
+
+build arm64 arm64-apple-macos11.0
+build x64 x86_64-apple-macos10.15

package/src/vendor/pi-tui/native/darwin/src/darwin-platform.m

@@ -0,0 +1,132 @@
+#import <AppKit/AppKit.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <Foundation/Foundation.h>
+#include <stdlib.h>
+#include <string.h>
+#define PI_CLIPBOARD_WRITE
+#include "../../clipboard.h"
+
+static CGEventFlags modifier_mask_for_name(const char* name) {
+    if (strcmp(name, "shift") == 0) return kCGEventFlagMaskShift;
+    if (strcmp(name, "command") == 0) return kCGEventFlagMaskCommand;
+    if (strcmp(name, "control") == 0) return kCGEventFlagMaskControl;
+    if (strcmp(name, "option") == 0) return kCGEventFlagMaskAlternate;
+    return 0;
+}
+
+static napi_value is_modifier_pressed(napi_env env, napi_callback_info info) {
+    napi_get_cb_info_fn napi_get_cb_info = (napi_get_cb_info_fn)node_symbol("napi_get_cb_info");
+    napi_get_value_string_utf8_fn napi_get_value_string_utf8 =
+        (napi_get_value_string_utf8_fn)node_symbol("napi_get_value_string_utf8");
+    napi_get_boolean_fn napi_get_boolean = (napi_get_boolean_fn)node_symbol("napi_get_boolean");
+
+    bool pressed = false;
+    if (napi_get_cb_info && napi_get_value_string_utf8) {
+        size_t argc = 1;
+        napi_value args[1] = {0};
+        if (napi_get_cb_info(env, info, &argc, args, 0, 0) == 0 && argc >= 1 && args[0]) {
+            char name[16] = {0};
+            size_t copied = 0;
+            if (napi_get_value_string_utf8(env, args[0], name, sizeof(name), &copied) == 0) {
+                CGEventFlags mask = modifier_mask_for_name(name);
+                if (mask != 0) {
+                    CGEventFlags flags = CGEventSourceFlagsState(kCGEventSourceStateCombinedSessionState);
+                    pressed = (flags & mask) != 0;
+                }
+            }
+        }
+    }
+
+    napi_value result = 0;
+    if (!napi_get_boolean || napi_get_boolean(env, pressed, &result) != 0) {
+        return fail(env, "Could not inspect modifier state");
+    }
+    return result;
+}
+
+static void clipboard_execute(clipboard_job* job) {
+    @autoreleasepool {
+        NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+        if (!pasteboard) {
+            job->error = "Could not open clipboard";
+        } else if (job->operation == CLIPBOARD_WRITE) {
+            NSString* text = [[NSString alloc] initWithBytes:job->data length:job->length encoding:NSUTF8StringEncoding];
+            if (!text) {
+                job->error = "Clipboard text is not valid UTF-8";
+                return;
+            }
+            [pasteboard clearContents];
+            if (![pasteboard setString:text forType:NSPasteboardTypeString]) job->error = "Could not set clipboard text";
+        } else if (job->operation == CLIPBOARD_TEXT) {
+            NSString* text = [pasteboard stringForType:NSPasteboardTypeString];
+            if (!text) {
+                job->format = CLIPBOARD_EMPTY;
+            } else if (!text.UTF8String) {
+                job->error = "Could not encode clipboard text";
+            } else {
+                clipboard_copy(job, text.UTF8String, [text lengthOfBytesUsingEncoding:NSUTF8StringEncoding], CLIPBOARD_UTF8);
+            }
+        } else if (job->operation == CLIPBOARD_FILES) {
+            NSArray* urls = [pasteboard readObjectsForClasses:@[[NSURL class]]
+                options:@{NSPasteboardURLReadingFileURLsOnlyKey: @YES}];
+            size_t total = 0;
+            for (NSURL* url in urls) {
+                const char* path = url.fileSystemRepresentation;
+                if (!path) continue;
+                size_t length = strlen(path);
+                if (length == SIZE_MAX || total > SIZE_MAX - length - 1) {
+                    job->error = "Clipboard file paths are too large";
+                    return;
+                }
+                total += length + 1;
+            }
+            if (total == 0) {
+                job->format = CLIPBOARD_EMPTY;
+                return;
+            }
+            char* paths = clipboard_alloc(total);
+            if (!paths) {
+                job->error = "Out of memory";
+                return;
+            }
+            char* cursor = paths;
+            for (NSURL* url in urls) {
+                const char* path = url.fileSystemRepresentation;
+                if (!path) continue;
+                size_t length = strlen(path);
+                memcpy(cursor, path, length + 1);
+                cursor += length + 1;
+            }
+            job->data = paths;
+            job->length = total;
+            job->format = CLIPBOARD_PATHS;
+        } else {
+            if (![pasteboard availableTypeFromArray:@[ NSPasteboardTypePNG, NSPasteboardTypeTIFF ]]) {
+                job->format = CLIPBOARD_EMPTY;
+                return;
+            }
+            NSData* png = [pasteboard dataForType:NSPasteboardTypePNG];
+            if (!png) {
+                NSImage* image = [[NSImage alloc] initWithPasteboard:pasteboard];
+                NSData* tiff = image.TIFFRepresentation;
+                NSBitmapImageRep* bitmap = tiff ? [NSBitmapImageRep imageRepWithData:tiff] : nil;
+                png = bitmap ? [bitmap representationUsingType:NSBitmapImageFileTypePNG properties:@{}] : nil;
+            }
+            if (png) clipboard_copy(job, png.bytes, png.length, CLIPBOARD_BUFFER);
+            else job->error = "Clipboard does not contain an image";
+        }
+    }
+}
+
+static napi_value PI_NAPI_CALL get_clipboard_file_paths(napi_env env, napi_callback_info info) {
+    return queue_clipboard(env, info, CLIPBOARD_FILES);
+}
+
+PI_NAPI_EXPORT napi_value napi_register_module_v1(napi_env env, napi_value exports) {
+    set_function_export(env, exports, "isModifierPressed", is_modifier_pressed);
+    set_function_export(env, exports, "getText", get_clipboard_text);
+    set_function_export(env, exports, "setText", set_clipboard_text);
+    set_function_export(env, exports, "getImage", get_clipboard_image);
+    set_function_export(env, exports, "getFilePaths", get_clipboard_file_paths);
+    return exports;
+}

package/src/vendor/pi-tui/native/linux/README.md

@@ -0,0 +1,23 @@
+# Linux clipboard helper
+
+Provides asynchronous X11 text and image reads using `libxcb.so.1`. Prebuilds support x64 and arm64 on glibc and musl. Reads have bounded waits; if a native operation stalls, the helper remains unavailable until it finishes.
+
+Coding-agent falls back to command-line tools when native reads are unavailable. Wayland reads use `wl-paste`; all Linux writes use the existing command-line or terminal clipboard paths.
+
+## Building
+
+Install a C compiler and XCB development headers, then run from the repository root on each supported Linux architecture:
+
+```sh
+npm --prefix packages/tui run build:native:linux
+```
+
+## Testing
+
+Install the build dependencies plus `pkg-config`, `Xvfb`, and `xclip`, then run from `packages/tui`:
+
+```sh
+node --test test/native-clipboard-linux.test.ts
+```
+
+Tests use isolated X11 servers, not the desktop clipboard. They skip when dependencies are missing.

package/src/vendor/pi-tui/native/linux/build.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+compiler="${CC:-cc}"
+
+if [[ "$(uname -s)" != "Linux" ]]; then
+    echo "Linux native helpers must be built on Linux" >&2
+    exit 1
+fi
+
+case "$(uname -m)" in
+    x86_64)
+        arch="x64"
+        ;;
+    aarch64|arm64)
+        arch="arm64"
+        ;;
+    *)
+        echo "Unsupported Linux architecture: $(uname -m)" >&2
+        exit 1
+        ;;
+esac
+
+if ! command -v "$compiler" >/dev/null 2>&1; then
+    echo "Linux C compiler not found: $compiler" >&2
+    exit 1
+fi
+build_dir="$(mktemp -d "${TMPDIR:-/tmp}/pi-tui-linux.XXXXXX")"
+trap 'rm -rf "$build_dir"' EXIT
+
+common_flags=(
+    -std=c11
+    -D_POSIX_C_SOURCE=200809L
+    -Wall
+    -Wextra
+    -Werror
+    -Os
+    -flto
+    -fPIC
+    -pthread
+    -fvisibility=hidden
+    -fno-stack-protector
+    -shared
+    -nostdlib
+    -Wl,--unresolved-symbols=ignore-all
+    -Wl,--no-as-needed
+    -Wl,-O2
+    -Wl,--gc-sections
+    # A timed-out private thread may outlive the Node environment that loaded us.
+    -Wl,-z,nodelete
+    -Wl,-s
+)
+
+x11_output="$build_dir/linux-platform-x11.node"
+"$compiler" "${common_flags[@]}" \
+    "$script_dir/src/linux-platform-x11.c" \
+    -lxcb \
+    -o "$x11_output"
+
+output_dir="$script_dir/prebuilds/linux-$arch"
+mkdir -p "$output_dir"
+install -m 755 "$x11_output" "$output_dir/linux-platform-x11.node"
+printf 'Built %s\n' "$output_dir/linux-platform-x11.node"

package/src/vendor/pi-tui/native/linux/src/clipboard-worker.h

@@ -0,0 +1,70 @@
+#include <pthread.h>
+#include <time.h>
+#include "../../clipboard.h"
+
+static void read_clipboard(clipboard_job* job);
+static pthread_mutex_t worker_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_once_t worker_once = PTHREAD_ONCE_INIT;
+static pthread_cond_t worker_changed;
+static bool worker_ready, worker_busy, worker_waiting, worker_finished;
+static clipboard_job worker_result;
+static int (*signal_worker)(pthread_cond_t*);
+static int (*wait_for_worker)(pthread_cond_t*, pthread_mutex_t*, const struct timespec*);
+
+static void initialize_worker_condition(void) {
+    // Unversioned ELF imports otherwise bind obsolete condition variables on glibc x64.
+    int (*initialize)(pthread_cond_t*, const pthread_condattr_t*) = node_symbol("pthread_cond_init");
+    signal_worker = node_symbol("pthread_cond_signal");
+    wait_for_worker = node_symbol("pthread_cond_timedwait");
+    if (!initialize || !signal_worker || !wait_for_worker) return;
+    pthread_condattr_t attributes;
+    if (pthread_condattr_init(&attributes) != 0) return;
+    worker_ready = pthread_condattr_setclock(&attributes, CLOCK_MONOTONIC) == 0 &&
+        initialize(&worker_changed, &attributes) == 0;
+    pthread_condattr_destroy(&attributes);
+}
+
+static void* read_on_private_thread(void* unused) {
+    (void)unused;
+    read_clipboard(&worker_result);
+    pthread_mutex_lock(&worker_mutex);
+    worker_finished = true;
+    if (!worker_waiting) {
+        free(worker_result.data); // The caller timed out; discard the late result.
+        worker_busy = false;
+    }
+    signal_worker(&worker_changed);
+    pthread_mutex_unlock(&worker_mutex);
+    return 0;
+}
+
+static void clipboard_execute(clipboard_job* job) {
+    pthread_once(&worker_once, initialize_worker_condition);
+    if (!worker_ready) return;
+    pthread_mutex_lock(&worker_mutex);
+    if (!worker_busy) {
+        worker_busy = worker_waiting = true;
+        worker_finished = false;
+        worker_result = (clipboard_job){.operation = job->operation};
+        struct timespec deadline;
+        clock_gettime(CLOCK_MONOTONIC, &deadline);
+        deadline.tv_sec += 3; // Allow the two-second transfer deadline to report its own error first.
+        pthread_t thread;
+        if (pthread_create(&thread, 0, read_on_private_thread, 0) == 0) {
+            pthread_detach(thread);
+            // Only this bounded wait occupies libuv. Other callers return unavailable.
+            while (!worker_finished && wait_for_worker(&worker_changed, &worker_mutex, &deadline) == 0) {}
+            if (worker_finished) {
+                job->data = worker_result.data;
+                job->length = worker_result.length;
+                job->format = worker_result.format;
+                job->error = worker_result.error;
+                worker_busy = false;
+            }
+        } else {
+            worker_busy = false;
+        }
+        worker_waiting = false;
+    }
+    pthread_mutex_unlock(&worker_mutex);
+}