cohere-transcribe 0.1.0

data/ext/cohere_transcribe_native/test/audio_reliability_smoke.cpp

@@ -0,0 +1,198 @@
+#include <atomic>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <dlfcn.h>
+#include <fstream>
+#include <iostream>
+#include <random>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace {
+
+using Probe = int (*)(char*, std::size_t);
+using Duration = int (*)(const char*, double*, char*, std::size_t);
+using Decode = int (*)(const char*, int, std::uint64_t, float**, std::int64_t*, char*, std::size_t);
+using Cancel = void (*)();
+using Free = void (*)(void*);
+
+template <typename Function>
+Function load(void* library, const char* name) {
+    auto function = reinterpret_cast<Function>(dlsym(library, name));
+    if (!function)
+        throw std::runtime_error(std::string("missing symbol ") + name);
+    return function;
+}
+
+template <typename Integer>
+void little_endian(std::vector<std::uint8_t>& bytes, Integer value) {
+    for (std::size_t index = 0; index < sizeof(value); ++index)
+        bytes.push_back(static_cast<std::uint8_t>((static_cast<std::uint64_t>(value) >> (8 * index)) & 0xff));
+}
+
+std::vector<std::uint8_t> wav_fixture() {
+    constexpr std::uint32_t frames = 400;
+    constexpr std::uint32_t rate = 16'000;
+    constexpr std::uint16_t channels = 2;
+    constexpr std::uint32_t pcm_bytes = frames * channels * sizeof(std::int16_t);
+    std::vector<std::uint8_t> bytes;
+    const auto append = [&](const char* text, std::size_t length) {
+        bytes.insert(bytes.end(), text, text + length);
+    };
+    append("RIFF", 4);
+    little_endian(bytes, 36U + pcm_bytes);
+    append("WAVEfmt ", 8);
+    little_endian(bytes, 16U);
+    little_endian(bytes, static_cast<std::uint16_t>(1));
+    little_endian(bytes, channels);
+    little_endian(bytes, rate);
+    little_endian(bytes, static_cast<std::uint32_t>(rate * channels * sizeof(std::int16_t)));
+    little_endian(bytes, static_cast<std::uint16_t>(channels * sizeof(std::int16_t)));
+    little_endian(bytes, static_cast<std::uint16_t>(16));
+    append("data", 4);
+    little_endian(bytes, pcm_bytes);
+    for (std::uint32_t index = 0; index < frames; ++index) {
+        little_endian(bytes, static_cast<std::uint16_t>(16'384));
+        little_endian(bytes, static_cast<std::uint16_t>(-8'192));
+    }
+    return bytes;
+}
+
+void write_bytes(const std::string& path, const std::vector<std::uint8_t>& bytes) {
+    std::ofstream output(path, std::ios::binary | std::ios::trunc);
+    output.write(reinterpret_cast<const char*>(bytes.data()), static_cast<std::streamsize>(bytes.size()));
+    if (!output)
+        throw std::runtime_error("could not write audio reliability fixture");
+}
+
+void check_decode_result(int status, float* samples, std::int64_t count,
+                         std::uint64_t maximum_bytes, Free release) {
+    if (status == 0) {
+        if (count < 0 || (count > 0 && !samples) ||
+            static_cast<std::uint64_t>(count) > maximum_bytes / sizeof(float)) {
+            release(samples);
+            throw std::runtime_error("successful decode returned invalid ownership metadata");
+        }
+        for (std::int64_t index = 0; index < count; ++index) {
+            if (!std::isfinite(samples[index])) {
+                release(samples);
+                throw std::runtime_error("successful decode returned a non-finite sample");
+            }
+        }
+    } else if (samples || count != 0) {
+        release(samples);
+        throw std::runtime_error("failed decode retained output ownership metadata");
+    }
+    release(samples);
+}
+
+} // namespace
+
+int main(int argc, char** argv) try {
+    if (argc != 3)
+        throw std::runtime_error("usage: audio_reliability_smoke ADAPTER PATH_PREFIX");
+    void* library = dlopen(argv[1], RTLD_NOW | RTLD_LOCAL);
+    if (!library)
+        throw std::runtime_error(dlerror());
+
+    const auto probe = load<Probe>(library, "cohere_audio_ffmpeg_probe");
+    const auto duration = load<Duration>(library, "cohere_audio_ffmpeg_duration");
+    const auto decode = load<Decode>(library, "cohere_audio_ffmpeg_decode");
+    const auto cancel = load<Cancel>(library, "cohere_audio_ffmpeg_cancel");
+    const auto release = load<Free>(library, "cohere_audio_ffmpeg_free");
+    char diagnostic[1024] = {};
+    if (probe(diagnostic, sizeof(diagnostic)) != 0)
+        throw std::runtime_error(diagnostic);
+    probe(nullptr, 0);
+
+    const std::string valid_path = std::string(argv[2]) + "-valid.wav";
+    const std::string fuzz_path = std::string(argv[2]) + "-fuzz.bin";
+    const auto valid = wav_fixture();
+    write_bytes(valid_path, valid);
+
+    std::atomic<bool> concurrency_failed{false};
+    std::vector<std::thread> workers;
+    for (int worker = 0; worker < 8; ++worker) {
+        workers.emplace_back([&] {
+            for (int iteration = 0; iteration < 50; ++iteration) {
+                float* samples = nullptr;
+                std::int64_t count = 0;
+                char message[256] = {};
+                const int status = decode(valid_path.c_str(), 16'000, 4096, &samples, &count,
+                                          message, sizeof(message));
+                if (status != 0 || !samples || count != 400)
+                    concurrency_failed.store(true, std::memory_order_release);
+                release(samples);
+            }
+        });
+    }
+    for (auto& worker : workers)
+        worker.join();
+    if (concurrency_failed.load(std::memory_order_acquire))
+        throw std::runtime_error("concurrent valid decodes were not stable");
+
+    float* limited_samples = nullptr;
+    std::int64_t limited_count = 0;
+    if (decode(valid_path.c_str(), 16'000, 4, &limited_samples, &limited_count,
+               diagnostic, sizeof(diagnostic)) != 4 || limited_samples || limited_count != 0) {
+        release(limited_samples);
+        throw std::runtime_error("decoded-audio memory limit did not fail closed");
+    }
+
+    std::mt19937_64 random(0xC0E4EULL);
+    for (int iteration = 0; iteration < 1'000; ++iteration) {
+        std::vector<std::uint8_t> bytes;
+        if (iteration < 500) {
+            bytes = valid;
+            const std::size_t mutations = 1 + (random() % 32);
+            for (std::size_t mutation = 0; mutation < mutations; ++mutation)
+                bytes[random() % bytes.size()] = static_cast<std::uint8_t>(random());
+            if ((iteration % 3) == 0)
+                bytes.resize(random() % (bytes.size() + 1));
+        } else {
+            bytes.resize(random() % 65'536);
+            for (auto& byte : bytes)
+                byte = static_cast<std::uint8_t>(random());
+        }
+        write_bytes(fuzz_path, bytes);
+
+        double seconds = 99.0;
+        const int duration_status = duration(fuzz_path.c_str(), &seconds, diagnostic, sizeof(diagnostic));
+        if ((duration_status == 0 && (!std::isfinite(seconds) || seconds < 0.0)) ||
+            (duration_status != 0 && seconds != -1.0)) {
+            throw std::runtime_error("duration fuzz returned invalid output metadata");
+        }
+
+        float* samples = nullptr;
+        std::int64_t count = 0;
+        const int status = decode(fuzz_path.c_str(), 16'000, 64 * 1024, &samples, &count,
+                                  diagnostic, sizeof(diagnostic));
+        check_decode_result(status, samples, count, 64 * 1024, release);
+        if ((iteration % 97) == 0)
+            cancel();
+    }
+
+    float* recovered = nullptr;
+    std::int64_t recovered_count = 0;
+    const int recovered_status = decode(valid_path.c_str(), 16'000, 4096, &recovered,
+                                        &recovered_count, diagnostic, sizeof(diagnostic));
+    if (recovered_status != 0 || !recovered || recovered_count != 400) {
+        release(recovered);
+        throw std::runtime_error("cancellation or malformed input poisoned later decoding");
+    }
+    release(recovered);
+
+    std::remove(valid_path.c_str());
+    std::remove(fuzz_path.c_str());
+    dlclose(library);
+    std::cout << "audio ABI reliability smoke: 400 concurrent valid + 1000 malformed cases\n";
+    return 0;
+} catch (const std::exception& error) {
+    std::cerr << error.what() << '\n';
+    return 1;
+}

data/ext/cohere_transcribe_native/test/native_abi_reliability_smoke.cpp

@@ -0,0 +1,186 @@
+// Standalone ownership and invalid-argument reliability test for instrumented builds.
+//
+//   c++ -std=c++20 -O1 -g native_abi_reliability_smoke.cpp -ldl -pthread -o smoke
+//   ./smoke /path/to/libcrispasr.so /path/to/model.gguf
+
+#include <atomic>
+#include <cstdint>
+#include <cstring>
+#include <dlfcn.h>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace {
+
+template <typename Function>
+Function load(void* library, const char* name) {
+    auto function = reinterpret_cast<Function>(dlsym(library, name));
+    if (!function)
+        throw std::runtime_error(std::string("missing symbol ") + name);
+    return function;
+}
+
+struct open_params {
+    int abi_version;
+    int n_threads;
+    int use_gpu;
+    int verbosity;
+    int flash_attn;
+    int n_gpu_layers;
+    int reserved[6];
+};
+
+void require(bool condition, const char* message) {
+    if (!condition)
+        throw std::runtime_error(message);
+}
+
+} // namespace
+
+int main(int argc, char** argv) try {
+    if (argc != 3)
+        throw std::runtime_error("usage: native_abi_reliability_smoke LIBCRISPASR MODEL_GGUF");
+    void* library = dlopen(argv[1], RTLD_NOW | RTLD_LOCAL);
+    if (!library)
+        throw std::runtime_error(dlerror());
+
+    using Open = void* (*)(const char*, const char*, const open_params*);
+    using Close = void (*)(void*);
+    using ErrorKind = int (*)();
+    using ErrorMessage = const char* (*)();
+    using ResolveDevice = const char* (*)(const char*);
+    using Memory = int (*)(void*, std::uint64_t*, std::uint64_t*);
+    using Capacity = int (*)(void*);
+    using Cancel = int (*)(void*);
+    using Transcribe = void* (*)(void*, const float*, int, const char*);
+    using TranscribeBatch = void* (*)(void*, const float* const*, const int*, int, const char*);
+    using SetInteger = int (*)(void*, int);
+    using FreeResult = void (*)(void*);
+    using Count = int (*)(void*);
+    using IndexedCount = int (*)(void*, int);
+    using IndexedText = const char* (*)(void*, int);
+    using WordText = const char* (*)(void*, int, int);
+    using BatchAt = void* (*)(void*, int);
+
+    const auto open = load<Open>(library, "crispasr_session_open_with_params");
+    const auto close = load<Close>(library, "crispasr_session_close");
+    const auto error_kind = load<ErrorKind>(library, "crispasr_last_error_kind");
+    const auto error_message = load<ErrorMessage>(library, "crispasr_last_error_message");
+    const auto resolve_device = load<ResolveDevice>(library, "crispasr_runtime_resolve_device");
+    const auto memory = load<Memory>(library, "crispasr_session_memory");
+    const auto capacity = load<Capacity>(library, "crispasr_session_batch_capacity");
+    const auto cancel = load<Cancel>(library, "crispasr_session_cancel");
+    const auto transcribe = load<Transcribe>(library, "crispasr_session_transcribe_lang");
+    const auto transcribe_batch =
+        load<TranscribeBatch>(library, "crispasr_session_transcribe_batch_lang");
+    const auto set_tokens = load<SetInteger>(library, "crispasr_session_set_max_new_tokens");
+    const auto set_beam = load<SetInteger>(library, "crispasr_session_set_beam_size");
+    const auto set_guard = load<SetInteger>(library, "crispasr_session_set_repetition_loop_guard");
+    const auto free_result = load<FreeResult>(library, "crispasr_session_result_free");
+    const auto free_batch = load<FreeResult>(library, "crispasr_session_batch_result_free");
+    const auto segment_count = load<Count>(library, "crispasr_session_result_n_segments");
+    const auto segment_words = load<IndexedCount>(library, "crispasr_session_result_n_words");
+    const auto segment_text = load<IndexedText>(library, "crispasr_session_result_segment_text");
+    const auto word_text = load<WordText>(library, "crispasr_session_result_word_text");
+    const auto batch_count = load<Count>(library, "crispasr_session_batch_result_count");
+    const auto batch_at = load<BatchAt>(library, "crispasr_session_batch_result_at");
+
+    require(std::strcmp(resolve_device(nullptr), "cpu") == 0 ||
+                std::strcmp(resolve_device(nullptr), "cuda") == 0 ||
+                std::strcmp(resolve_device(nullptr), "mps") == 0,
+            "automatic device resolution returned an invalid value");
+    require(std::strcmp(resolve_device("invalid"), "") == 0,
+            "invalid device resolution did not fail closed");
+
+    for (int iteration = 0; iteration < 32; ++iteration) {
+        require(!open(nullptr, "cohere", nullptr), "null model path unexpectedly opened");
+        require(error_kind() == 1, "null model path returned the wrong error kind");
+        require(!open("", "cohere", nullptr), "empty model path unexpectedly opened");
+        require(!open("/definitely/missing/cohere.gguf", "other", nullptr),
+                "unsupported backend unexpectedly opened");
+    }
+
+    // Error state belongs to the calling thread and concurrent callers must not
+    // overwrite one another's diagnostics.
+    require(!open(nullptr, "cohere", nullptr), "main-thread error fixture failed");
+    const std::string main_message = error_message();
+    std::atomic<bool> thread_failed{false};
+    std::vector<std::thread> workers;
+    for (int worker = 0; worker < 8; ++worker) {
+        workers.emplace_back([&] {
+            for (int iteration = 0; iteration < 200; ++iteration) {
+                if (transcribe(nullptr, nullptr, 0, nullptr) || error_kind() != 1 ||
+                    std::strstr(error_message(), "invalid") == nullptr) {
+                    thread_failed.store(true, std::memory_order_release);
+                }
+            }
+        });
+    }
+    for (auto& worker : workers)
+        worker.join();
+    require(!thread_failed.load(std::memory_order_acquire),
+            "thread-local invalid-argument diagnostics were unstable");
+    require(error_kind() == 1 && main_message == error_message(),
+            "another thread overwrote the main-thread error state");
+
+    std::uint64_t free_bytes = 99;
+    std::uint64_t total_bytes = 99;
+    require(memory(nullptr, &free_bytes, &total_bytes) == -1 && free_bytes == 0 && total_bytes == 0,
+            "invalid memory query did not clear outputs");
+    require(memory(nullptr, nullptr, nullptr) == -1, "null memory outputs were accepted");
+    require(capacity(nullptr) == 0, "null session reported batch capacity");
+    require(cancel(nullptr) == -1, "null cancellation returned the wrong status");
+    require(set_tokens(nullptr, 1) == -1 && set_beam(nullptr, 1) == -1 && set_guard(nullptr, 1) == -1,
+            "null session setter was accepted");
+    require(segment_count(nullptr) == 0 && segment_words(nullptr, -1) == 0,
+            "null result reported members");
+    require(std::strcmp(segment_text(nullptr, -1), "") == 0 &&
+                std::strcmp(word_text(nullptr, -1, -1), "") == 0,
+            "null result returned text");
+    require(batch_count(nullptr) == 0 && !batch_at(nullptr, 0),
+            "null batch result reported a lane");
+    free_result(nullptr);
+    free_batch(nullptr);
+    close(nullptr);
+
+    const open_params params{2, 4, 0, 0, 1, -1, {}};
+    void* session = open(argv[2], "cohere", &params);
+    if (!session)
+        throw std::runtime_error(std::string("session open failed: ") + error_message());
+    try {
+        require(capacity(session) >= 1, "real session reported no batch capacity");
+        const float sample = 0.0f;
+        const float* rows[] = {&sample};
+        const int zero[] = {0};
+        const int too_long[] = {35 * 16'000 + 1};
+        require(!transcribe(session, nullptr, 1, "en") && error_kind() == 1,
+                "null single-row PCM was accepted");
+        require(!transcribe(session, &sample, 0, "en") && error_kind() == 1,
+                "empty single-row PCM was accepted");
+        require(!transcribe_batch(session, nullptr, zero, 1, "en") && error_kind() == 1,
+                "null batch PCM table was accepted");
+        require(!transcribe_batch(session, rows, nullptr, 1, "en") && error_kind() == 1,
+                "null batch size table was accepted");
+        require(!transcribe_batch(session, rows, zero, 1, "en") && error_kind() == 1,
+                "empty batch row was accepted");
+        require(!transcribe_batch(session, rows, too_long, 1, "en") && error_kind() == 1,
+                "oversized batch row was accepted");
+        require(!transcribe_batch(session, rows, zero, capacity(session) + 1, "en") &&
+                    error_kind() == 1,
+                "over-capacity batch was accepted");
+        require(cancel(session) == 0, "invalid calls poisoned the idle cancellation state");
+    } catch (...) {
+        close(session);
+        throw;
+    }
+    close(session);
+    dlclose(library);
+    std::cout << "native ABI reliability smoke: 32 opens + 1600 threaded failures + real-session bounds\n";
+    return 0;
+} catch (const std::exception& error) {
+    std::cerr << error.what() << '\n';
+    return 1;
+}

data/ext/cohere_transcribe_native/test/native_batch_projection_probe.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Focused real-model timing probe for one retained native session.
+#
+# Usage:
+#   ruby native_batch_projection_probe.rb \
+#     LIBCRISPASR LIBCOHERE_AUDIO MODEL_GGUF AUDIO [BATCH_SIZE] [ITERATIONS]
+
+require "digest"
+require "fiddle"
+require "json"
+
+native_library, audio_library, model_path, audio_path, batch_text, iterations_text = ARGV
+unless native_library && audio_library && model_path && audio_path
+  warn "usage: #{$PROGRAM_NAME} LIBCRISPASR LIBCOHERE_AUDIO MODEL_GGUF AUDIO [BATCH_SIZE] [ITERATIONS]"
+  exit 2
+end
+
+batch_size = Integer(batch_text || 24)
+iterations = Integer(iterations_text || 2)
+raise ArgumentError, "BATCH_SIZE must be between 1 and 24" unless batch_size.between?(1, 24)
+raise ArgumentError, "ITERATIONS must be positive" unless iterations.positive?
+
+ENV["COHERE_TRANSCRIBE_NATIVE_LIBRARY"] = File.expand_path(native_library)
+ENV["COHERE_TRANSCRIBE_AUDIO_LIBRARY"] = File.expand_path(audio_library)
+
+$LOAD_PATH.unshift(File.expand_path("../../../lib", __dir__))
+require "cohere/transcribe"
+
+options = Cohere::Transcribe::TranscriptionOptions.new(
+  device: ENV.fetch("COHERE_PROBE_DEVICE", "cuda"),
+  dtype: "fp16",
+  vad: "none",
+  alignment: "segment",
+  max_new_tokens: 445
+)
+samples = Cohere::Transcribe::Audio::Decoder.decode(audio_path, backend: "ffmpeg").samples
+session = Cohere::Transcribe::ASR::NativeSession.new(model_path, options, threads: 6)
+warmup_iterations = Integer(ENV.fetch("COHERE_PROBE_WARMUP_ITERATIONS", "0"))
+raise ArgumentError, "COHERE_PROBE_WARMUP_ITERATIONS must not be negative" if warmup_iterations.negative?
+
+profiler = if ENV["COHERE_PROBE_CUDA_CAPTURE"] == "1"
+             handle = Fiddle::Handle.new("libcudart.so.12")
+             [
+               handle,
+               Fiddle::Function.new(handle["cudaProfilerStart"], [], Fiddle::TYPE_INT),
+               Fiddle::Function.new(handle["cudaProfilerStop"], [], Fiddle::TYPE_INT)
+             ]
+           end
+profiler_started = false
+
+begin
+  warmup_iterations.times do
+    session.transcribe_batch(Array.new(batch_size, samples), language: "ar")
+  end
+  if profiler
+    status = profiler[1].call
+    raise "cudaProfilerStart failed with status #{status}" unless status.zero?
+
+    profiler_started = true
+  end
+
+  iterations.times do |iteration|
+    started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    output = session.transcribe_batch(Array.new(batch_size, samples), language: "ar")
+    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+    puts JSON.generate(
+      iteration: iteration + 1,
+      batch_size: batch_size,
+      elapsed_seconds: elapsed,
+      text_sha256: Digest::SHA256.hexdigest(output.map(&:text).join("\0")),
+      generated_tokens: output.map(&:generated_tokens)
+    )
+  end
+ensure
+  if profiler_started
+    status = profiler[2].call
+    warn "cudaProfilerStop failed with status #{status}" unless status.zero?
+  end
+  session.close
+end

data/ext/cohere_transcribe_native/test/native_cancellation_smoke.cpp

@@ -0,0 +1,194 @@
+// Standalone real-model cancellation/lifetime smoke test for sanitizer builds.
+//
+//   c++ -std=c++20 -O1 -g -pthread native_cancellation_smoke.cpp -ldl -o smoke
+//   ASAN_OPTIONS=detect_leaks=1 ./smoke /path/to/libcrispasr.so /path/to/model.gguf
+
+// Keeping this process independent from Ruby avoids false positives from
+// ASan's interaction with Ruby's separately mapped fiber stacks.
+
+#include <atomic>
+#include <chrono>
+#include <cstdint>
+#include <cstring>
+#include <dlfcn.h>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace {
+
+template <typename Function>
+Function load(void* library, const char* name) {
+    dlerror();
+    auto function = reinterpret_cast<Function>(dlsym(library, name));
+    const char* error = dlerror();
+    if (error || !function)
+        throw std::runtime_error(std::string("missing symbol ") + name + ": " +
+                                 (error ? error : "unknown loader error"));
+    return function;
+}
+
+struct open_params {
+    int abi_version;
+    int n_threads;
+    int use_gpu;
+    int verbosity;
+    int flash_attn;
+    int n_gpu_layers;
+    int reserved[6];
+};
+
+struct worker_outcome {
+    void* result = nullptr;
+    int error_kind = -1;
+    std::string error_message;
+};
+
+} // namespace
+
+int main(int argc, char** argv) try {
+    if (argc != 3)
+        throw std::runtime_error("usage: native_cancellation_smoke LIBCRISPASR MODEL_GGUF");
+
+    void* library = dlopen(argv[1], RTLD_NOW | RTLD_LOCAL);
+    if (!library)
+        throw std::runtime_error(dlerror());
+
+    using Open = void* (*)(const char*, const char*, const open_params*);
+    using Close = void (*)(void*);
+    using Cancel = int (*)(void*);
+    using Transcribe = void* (*)(void*, const float*, int, const char*);
+    using TranscribeBatch = void* (*)(void*, const float* const*, const int*, int, const char*);
+    using FreeResult = void (*)(void*);
+    using BatchCount = int (*)(void*);
+    using FreeBatchResult = void (*)(void*);
+    using ErrorKind = int (*)();
+    using ErrorMessage = const char* (*)();
+    using SetInteger = int (*)(void*, int);
+
+    const auto open = load<Open>(library, "crispasr_session_open_with_params");
+    const auto close = load<Close>(library, "crispasr_session_close");
+    const auto cancel = load<Cancel>(library, "crispasr_session_cancel");
+    const auto transcribe = load<Transcribe>(library, "crispasr_session_transcribe_lang");
+    const auto transcribe_batch =
+        load<TranscribeBatch>(library, "crispasr_session_transcribe_batch_lang");
+    const auto free_result = load<FreeResult>(library, "crispasr_session_result_free");
+    const auto batch_count = load<BatchCount>(library, "crispasr_session_batch_result_count");
+    const auto free_batch_result =
+        load<FreeBatchResult>(library, "crispasr_session_batch_result_free");
+    const auto error_kind = load<ErrorKind>(library, "crispasr_last_error_kind");
+    const auto error_message = load<ErrorMessage>(library, "crispasr_last_error_message");
+    const auto set_max_tokens = load<SetInteger>(library, "crispasr_session_set_max_new_tokens");
+
+    const open_params params{2, 4, 0, 0, 1, -1, {}};
+    void* session = open(argv[2], "cohere", &params);
+    if (!session)
+        throw std::runtime_error(std::string("session open failed: ") + error_message());
+
+    try {
+        if (cancel(session) != 0)
+            throw std::runtime_error("idle cancellation was not a no-op");
+        if (set_max_tokens(session, 64) != 0)
+            throw std::runtime_error("could not set the generation limit");
+
+        // A maximum-length row leaves ample time to observe the running state,
+        // even on a fast host. Repeating exercises reset-to-idle and retained
+        // graph lifetime after several abort points.
+        const std::vector<float> long_audio(35 * 16'000, 0.0f);
+        for (int iteration = 0; iteration < 5; ++iteration) {
+            std::atomic<bool> entered{false};
+            worker_outcome outcome;
+            std::thread worker([&] {
+                entered.store(true, std::memory_order_release);
+                outcome.result = transcribe(
+                    session,
+                    long_audio.data(),
+                    static_cast<int>(long_audio.size()),
+                    "en");
+                outcome.error_kind = error_kind();
+                const char* message = error_message();
+                outcome.error_message = message ? message : "";
+            });
+
+            while (!entered.load(std::memory_order_acquire))
+                std::this_thread::yield();
+
+            bool requested = false;
+            const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(30);
+            while (std::chrono::steady_clock::now() < deadline) {
+                if (cancel(session) == 1) {
+                    requested = true;
+                    break;
+                }
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            }
+            if (!requested) {
+                worker.join();
+                free_result(outcome.result);
+                throw std::runtime_error("never observed an active inference operation");
+            }
+
+            worker.join();
+            if (outcome.result) {
+                free_result(outcome.result);
+                throw std::runtime_error("cancelled inference returned a result");
+            }
+            if (outcome.error_kind != 5 || outcome.error_message.find("cancel") == std::string::npos)
+                throw std::runtime_error("cancelled inference returned the wrong typed diagnostic");
+            if (cancel(session) != 0)
+                throw std::runtime_error("completed cancellation poisoned the idle session");
+        }
+
+        // Prove the retained session remains usable after repeated aborts.
+        if (set_max_tokens(session, 4) != 0)
+            throw std::runtime_error("could not set the reuse generation limit");
+        const std::vector<float> short_audio(16'000, 0.0f);
+        void* reused = transcribe(
+            session,
+            short_audio.data(),
+            static_cast<int>(short_audio.size()),
+            "en");
+        if (!reused)
+            throw std::runtime_error(std::string("post-cancellation reuse failed: ") + error_message());
+        free_result(reused);
+        if (cancel(session) != 0)
+            throw std::runtime_error("post-reuse idle cancellation was not a no-op");
+
+        // Exercise the independent padded-encoder/ragged-decoder ownership
+        // path after a cancelled single-row graph has been replaced.
+        const float* rows[] = {short_audio.data(), short_audio.data()};
+        const int row_sizes[] = {
+            static_cast<int>(short_audio.size()),
+            static_cast<int>(short_audio.size()),
+        };
+        void* batch = transcribe_batch(session, rows, row_sizes, 2, "en");
+        if (!batch)
+            throw std::runtime_error(std::string("post-cancellation batch failed: ") + error_message());
+        if (batch_count(batch) != 2) {
+            free_batch_result(batch);
+            throw std::runtime_error("post-cancellation batch returned the wrong row count");
+        }
+        free_batch_result(batch);
+        if (cancel(session) != 0)
+            throw std::runtime_error("post-batch idle cancellation was not a no-op");
+    } catch (...) {
+        close(session);
+#if !defined(COHERE_SANITIZER_KEEP_LIBRARY_LOADED)
+        dlclose(library);
+#endif
+        throw;
+    }
+
+    close(session);
+#if !defined(COHERE_SANITIZER_KEEP_LIBRARY_LOADED)
+    dlclose(library);
+#endif
+    std::cout << "verified five cancellations plus single-row and batch reuse\n";
+    return 0;
+} catch (const std::exception& error) {
+    std::cerr << error.what() << '\n';
+    return 1;
+}

data/lib/cohere/transcribe/alignment/ATTRIBUTION.md

@@ -0,0 +1,23 @@
+# Word-alignment attribution
+
+## Downloaded MMS model
+
+The optional word-alignment runtime downloads the full-precision ONNX export of `MahmoudAshraf/mms-300m-1130-forced-aligner` into the user's Hugging Face cache. The export is pinned to `onnx-community/mms-300m-1130-forced-aligner-ONNX@2100fb247d8e43962eef24491597fbeb8b469531` and is derived from the source checkpoint revision `49402e9577b1158620820667c218cd494cc44486`.
+
+The model is licensed under CC-BY-NC-4.0, including its non-commercial-use restriction. The model weights are downloaded only when word mode is used and are not distributed inside this gem. The runtime pins and verifies these artifacts before loading them:
+
+- `onnx/model.onnx`: 1,262,529,881 bytes, SHA-256 `429e5d05c62acc8a9264db874a1b131e359fc626e40c253ac7b1fe52b11149b4`
+- `onnx/model_fp16.onnx`: 631,591,191 bytes, SHA-256 `e98082b382375f3528ec7514e175b5cd0eb77fcc4d4531a7142b9e45a1ce6deb`
+
+See:
+
+- <https://huggingface.co/MahmoudAshraf/mms-300m-1130-forced-aligner>
+- <https://huggingface.co/onnx-community/mms-300m-1130-forced-aligner-ONNX>
+
+## Packaged alignment code
+
+Normalization, punctuation, repeated-token merging, and span behavior in `text.rb` and `ctc.rb` retain modified behavior from Fairseq MMS at revision `728b947019fd186753197add48c39cbb24ea43e2` and `ctc-forced-aligner` at revision `11855d1de76af2b490dd2e8e2db2661805ae90a0`. These bundled portions are distributed under CC-BY-NC-4.0; see `LICENSE.ctc-forced-aligner`.
+
+The float32 CTC dynamic program in `ctc.rb` is a Ruby port of the TorchAudio 2.11.0 `forced_align` CPU kernel's documented state transitions and tie-breaking behavior. TorchAudio is BSD-2-Clause licensed; see `LICENSE.torchaudio`.
+
+Romanization uses static, pure-Ruby single-codepoint data generated from the Uroman 1.3.1.1 reference for every character reachable from the pinned Cohere tokenizers, together with the reachable Greek and Japanese multi-codepoint/context rules. It does not invoke Python or an external romanizer at runtime. Uroman is written by Ulf Hermjakob, USC Information Sciences Institute (2015-2020), and is distributed under the permissive terms in `LICENSE.uroman`.