cohere-transcribe 0.1.0

data/ext/cohere_transcribe_native/exports.macos

@@ -0,0 +1,40 @@
+_crispasr_bf16_to_fp32_row
+_crispasr_fp16_to_fp32_row
+_crispasr_fp32_to_fp16_row
+_crispasr_fp32_to_bf16_row
+_crispasr_last_error_kind
+_crispasr_last_error_message
+_crispasr_runtime_resolve_device
+_crispasr_runtime_supports_bf16
+_crispasr_set_gpu_backend
+_crispasr_session_open_with_params
+_crispasr_session_backend
+_crispasr_session_compute_backend
+_crispasr_session_memory
+_crispasr_session_batch_capacity
+_crispasr_session_cancel
+_crispasr_session_transcribe_lang
+_crispasr_session_transcribe_batch_lang
+_crispasr_session_batch_result_count
+_crispasr_session_batch_result_stats_v1
+_crispasr_session_batch_result_at
+_crispasr_session_batch_result_free
+_crispasr_session_result_n_segments
+_crispasr_session_result_segment_text
+_crispasr_session_result_segment_t0
+_crispasr_session_result_segment_t1
+_crispasr_session_result_n_words
+_crispasr_session_result_word_text
+_crispasr_session_result_word_t0
+_crispasr_session_result_word_t1
+_crispasr_session_result_word_p
+_crispasr_session_result_generated_tokens
+_crispasr_session_result_generation_limit
+_crispasr_session_result_generation_capacity
+_crispasr_session_result_stopped_by_max_tokens
+_crispasr_session_result_repetition_stopped
+_crispasr_session_result_free
+_crispasr_session_close
+_crispasr_session_set_max_new_tokens
+_crispasr_session_set_beam_size
+_crispasr_session_set_repetition_loop_guard

data/ext/cohere_transcribe_native/exports.map

@@ -0,0 +1,45 @@
+{
+    global:
+        crispasr_bf16_to_fp32_row;
+        crispasr_fp16_to_fp32_row;
+        crispasr_fp32_to_fp16_row;
+        crispasr_fp32_to_bf16_row;
+        crispasr_last_error_kind;
+        crispasr_last_error_message;
+        crispasr_runtime_resolve_device;
+        crispasr_runtime_supports_bf16;
+        crispasr_set_gpu_backend;
+        crispasr_session_open_with_params;
+        crispasr_session_backend;
+        crispasr_session_compute_backend;
+        crispasr_session_memory;
+        crispasr_session_batch_capacity;
+        crispasr_session_cancel;
+        crispasr_session_transcribe_lang;
+        crispasr_session_transcribe_batch_lang;
+        crispasr_session_batch_result_count;
+        crispasr_session_batch_result_stats_v1;
+        crispasr_session_batch_result_at;
+        crispasr_session_batch_result_free;
+        crispasr_session_result_n_segments;
+        crispasr_session_result_segment_text;
+        crispasr_session_result_segment_t0;
+        crispasr_session_result_segment_t1;
+        crispasr_session_result_n_words;
+        crispasr_session_result_word_text;
+        crispasr_session_result_word_t0;
+        crispasr_session_result_word_t1;
+        crispasr_session_result_word_p;
+        crispasr_session_result_generated_tokens;
+        crispasr_session_result_generation_limit;
+        crispasr_session_result_generation_capacity;
+        crispasr_session_result_stopped_by_max_tokens;
+        crispasr_session_result_repetition_stopped;
+        crispasr_session_result_free;
+        crispasr_session_close;
+        crispasr_session_set_max_new_tokens;
+        crispasr_session_set_beam_size;
+        crispasr_session_set_repetition_loop_guard;
+    local:
+        *;
+};

data/ext/cohere_transcribe_native/extconf.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rbconfig"
+require "shellwords"
+
+EXTENSION_DIR = File.expand_path(__dir__)
+GEM_ROOT = File.expand_path("../..", EXTENSION_DIR)
+
+def enabled?(name)
+  value = ENV.fetch(name, nil)
+  value && !value.empty? && !%w[0 false no off].include?(value.downcase)
+end
+
+host_os = RbConfig::CONFIG.fetch("host_os")
+abort "cohere-transcribe's vendored native runtime currently supports Linux and macOS source builds" unless host_os.match?(/linux|darwin/)
+
+cuda = enabled?("COHERE_TRANSCRIBE_CUDA")
+metal = enabled?("COHERE_TRANSCRIBE_METAL")
+abort "COHERE_TRANSCRIBE_METAL=1 is only supported on macOS" if metal && !host_os.match?(/darwin/)
+abort "COHERE_TRANSCRIBE_CUDA=1 is only supported on Linux" if cuda && !host_os.match?(/linux/)
+abort "enable either CUDA or Metal, not both" if cuda && metal
+
+cmake = ENV.fetch("CMAKE", "cmake")
+unless system(cmake, "--version", out: File::NULL, err: File::NULL)
+  abort "cmake 3.14 or newer is required to build cohere-transcribe's native runtime"
+end
+
+build_dir = File.expand_path(
+  ENV.fetch("COHERE_TRANSCRIBE_NATIVE_BUILD_DIR", File.join(GEM_ROOT, "tmp", "cohere_transcribe_native"))
+)
+output_dir = File.expand_path(
+  ENV.fetch(
+    "COHERE_TRANSCRIBE_NATIVE_OUTPUT",
+    File.join(GEM_ROOT, "lib", "cohere", "transcribe", "native")
+  )
+)
+build_type = ENV.fetch("COHERE_TRANSCRIBE_BUILD_TYPE", "Release")
+
+cmake_options = {
+  "COHERE_TRANSCRIBE_CUDA" => cuda,
+  "COHERE_TRANSCRIBE_METAL" => metal,
+  "COHERE_TRANSCRIBE_NATIVE" => enabled?("COHERE_TRANSCRIBE_NATIVE"),
+  "COHERE_TRANSCRIBE_OPENMP" => enabled?("COHERE_TRANSCRIBE_OPENMP")
+}
+
+configure = [
+  cmake,
+  "-S", EXTENSION_DIR,
+  "-B", build_dir,
+  "-DCMAKE_BUILD_TYPE=#{build_type}",
+  *cmake_options.map { |name, value| "-D#{name}=#{value ? "ON" : "OFF"}" },
+  *Shellwords.split(ENV.fetch("COHERE_TRANSCRIBE_CMAKE_ARGS", ""))
+]
+build = [cmake, "--build", build_dir, "--config", build_type, "--target", "crispasr", "cohere_audio"]
+jobs = ENV.fetch("COHERE_TRANSCRIBE_NATIVE_JOBS", nil)
+build.push("--parallel", Integer(jobs, 10).to_s) if jobs && !jobs.empty?
+install = [
+  cmake,
+  "--install", build_dir,
+  "--config", build_type,
+  "--prefix", output_dir,
+  "--component", "cohere_transcribe_runtime"
+]
+smoke = [RbConfig.ruby, File.join(EXTENSION_DIR, "test", "abi_smoke.rb"), output_dir]
+
+FileUtils.mkdir_p(build_dir)
+
+makefile = <<~MAKEFILE
+  .PHONY: all install check clean distclean
+
+  all:
+  \t#{Shellwords.join(configure)}
+  \t#{Shellwords.join(build)}
+  \t#{Shellwords.join(install)}
+
+  install: all
+
+  check: all
+  \t#{Shellwords.join(smoke)}
+
+  clean:
+  \t#{Shellwords.join([cmake, "-E", "remove_directory", build_dir])}
+
+  distclean: clean
+MAKEFILE
+
+File.write(File.join(EXTENSION_DIR, "Makefile"), makefile)
+puts "Native runtime will be installed in #{output_dir}"

data/ext/cohere_transcribe_native/test/abi_smoke.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "fiddle"
+require "rbconfig"
+require "tmpdir"
+
+directory = File.expand_path(ARGV.fetch(0))
+patterns = case RbConfig::CONFIG.fetch("host_os")
+           when /darwin/ then ["libcrispasr*.dylib"]
+           when /mswin|mingw/ then ["crispasr*.dll", "libcrispasr*.dll"]
+           else ["libcrispasr.so", "libcrispasr.so.*"]
+           end
+library = patterns.flat_map { |pattern| Dir.glob(File.join(directory, pattern)) }.min
+abort "no packaged libcrispasr found in #{directory}" unless library
+
+handle = Fiddle::Handle.new(library, Fiddle::RTLD_NOW | Fiddle::RTLD_GLOBAL)
+symbols = %w[
+  crispasr_bf16_to_fp32_row
+  crispasr_fp16_to_fp32_row
+  crispasr_fp32_to_fp16_row
+  crispasr_fp32_to_bf16_row
+  crispasr_last_error_kind
+  crispasr_last_error_message
+  crispasr_set_gpu_backend
+  crispasr_runtime_resolve_device
+  crispasr_runtime_supports_bf16
+  crispasr_session_open_with_params
+  crispasr_session_backend
+  crispasr_session_compute_backend
+  crispasr_session_memory
+  crispasr_session_batch_capacity
+  crispasr_session_cancel
+  crispasr_session_transcribe_lang
+  crispasr_session_transcribe_batch_lang
+  crispasr_session_batch_result_count
+  crispasr_session_batch_result_stats_v1
+  crispasr_session_batch_result_at
+  crispasr_session_batch_result_free
+  crispasr_session_result_n_segments
+  crispasr_session_result_segment_text
+  crispasr_session_result_segment_t0
+  crispasr_session_result_segment_t1
+  crispasr_session_result_n_words
+  crispasr_session_result_word_text
+  crispasr_session_result_word_t0
+  crispasr_session_result_word_t1
+  crispasr_session_result_word_p
+  crispasr_session_result_generated_tokens
+  crispasr_session_result_generation_limit
+  crispasr_session_result_generation_capacity
+  crispasr_session_result_stopped_by_max_tokens
+  crispasr_session_result_repetition_stopped
+  crispasr_session_result_free
+  crispasr_session_close
+  crispasr_session_set_max_new_tokens
+  crispasr_session_set_beam_size
+  crispasr_session_set_repetition_loop_guard
+]
+symbols.each { |symbol| handle[symbol] }
+
+backend = Fiddle::Function.new(handle["crispasr_session_backend"], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_VOIDP)
+compute_backend = Fiddle::Function.new(
+  handle["crispasr_session_compute_backend"],
+  [Fiddle::TYPE_VOIDP],
+  Fiddle::TYPE_VOIDP
+)
+resolve_device = Fiddle::Function.new(
+  handle["crispasr_runtime_resolve_device"],
+  [Fiddle::TYPE_VOIDP],
+  Fiddle::TYPE_VOIDP
+)
+supports_bf16 = Fiddle::Function.new(
+  handle["crispasr_runtime_supports_bf16"],
+  [Fiddle::TYPE_VOIDP],
+  Fiddle::TYPE_INT
+)
+segments = Fiddle::Function.new(
+  handle["crispasr_session_result_n_segments"],
+  [Fiddle::TYPE_VOIDP],
+  Fiddle::TYPE_INT
+)
+batch_capacity = Fiddle::Function.new(
+  handle["crispasr_session_batch_capacity"],
+  [Fiddle::TYPE_VOIDP],
+  Fiddle::TYPE_INT
+)
+cancel_session = Fiddle::Function.new(
+  handle["crispasr_session_cancel"],
+  [Fiddle::TYPE_VOIDP],
+  Fiddle::TYPE_INT
+)
+last_error_kind = Fiddle::Function.new(
+  handle["crispasr_last_error_kind"],
+  [],
+  Fiddle::TYPE_INT
+)
+last_error_message = Fiddle::Function.new(
+  handle["crispasr_last_error_message"],
+  [],
+  Fiddle::TYPE_VOIDP
+)
+batch_transcribe = Fiddle::Function.new(
+  handle["crispasr_session_transcribe_batch_lang"],
+  [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
+  Fiddle::TYPE_VOIDP
+)
+max_tokens = Fiddle::Function.new(
+  handle["crispasr_session_set_max_new_tokens"],
+  [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT],
+  Fiddle::TYPE_INT
+)
+raise "initial native error kind must be zero" unless last_error_kind.call.zero?
+raise "initial native error message must be empty" unless Fiddle::Pointer.new(
+  last_error_message.call
+).to_s.empty?
+raise "null session backend must be an empty C string" unless Fiddle::Pointer.new(backend.call(0)).to_s.empty?
+raise "null session compute backend must be an empty C string" unless Fiddle::Pointer.new(
+  compute_backend.call(0)
+).to_s.empty?
+
+cpu = Fiddle::Pointer["cpu\0"]
+auto = Fiddle::Pointer["auto\0"]
+raise "CPU must always resolve" unless Fiddle::Pointer.new(resolve_device.call(cpu)).to_s == "cpu"
+raise "CPU precision contract must use FP32" unless supports_bf16.call(cpu).zero?
+unless %w[cpu cuda mps].include?(Fiddle::Pointer.new(resolve_device.call(auto)).to_s)
+  raise "auto device resolution returned an unsupported value"
+end
+raise "null result must contain no segments" unless segments.call(0).zero?
+raise "null session must have no batch capacity" unless batch_capacity.call(0).zero?
+raise "null session cancellation must fail" unless cancel_session.call(0) == -1
+raise "null session setter must fail" unless max_tokens.call(0, 1) == -1
+
+failed, failure_kind, failure_message = Thread.new do
+  result = batch_transcribe.call(0, 0, 0, 1, 0)
+  [result.null?, last_error_kind.call, Fiddle::Pointer.new(last_error_message.call).to_s]
+end.value
+raise "invalid batch arguments must fail" unless failed
+raise "invalid batch arguments must be classified" unless failure_kind == 1
+raise "invalid batch arguments must include a diagnostic message" unless failure_message.include?("invalid batch transcription")
+raise "native diagnostics must remain thread-local" unless last_error_kind.call.zero?
+
+puts "verified #{symbols.length} Cohere session ABI symbols in #{File.basename(library)}"
+
+audio_patterns = case RbConfig::CONFIG.fetch("host_os")
+                 when /darwin/ then ["libcohere_audio*.dylib"]
+                 when /mswin|mingw/ then ["cohere_audio*.dll", "libcohere_audio*.dll"]
+                 else ["libcohere_audio.so", "libcohere_audio.so.*"]
+                 end
+audio_library = audio_patterns.flat_map do |pattern|
+  Dir.glob(File.join(directory, pattern))
+end.min
+abort "no packaged libcohere_audio found in #{directory}" unless audio_library
+
+audio_handle = Fiddle::Handle.new(audio_library, Fiddle::RTLD_NOW)
+audio_symbols = %w[
+  cohere_audio_ffmpeg_probe
+  cohere_audio_ffmpeg_decode
+  cohere_audio_ffmpeg_duration
+  cohere_audio_ffmpeg_cancel
+  cohere_audio_ffmpeg_free
+]
+audio_symbols.each { |symbol| audio_handle[symbol] }
+probe = Fiddle::Function.new(
+  audio_handle["cohere_audio_ffmpeg_probe"],
+  [Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T],
+  Fiddle::TYPE_INT
+)
+diagnostic = Fiddle::Pointer.malloc(1_024, Fiddle::RUBY_FREE)
+diagnostic[0, 1_024] = "\0" * 1_024
+probe_status = probe.call(diagnostic, 1_024)
+raise "audio probe returned an invalid status" unless [0, 1].include?(probe_status)
+raise "audio probe returned no diagnostic" if diagnostic.to_s.empty?
+
+if probe_status.zero?
+  duration = Fiddle::Function.new(
+    audio_handle["cohere_audio_ffmpeg_duration"],
+    [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T],
+    Fiddle::TYPE_INT
+  )
+  decode = Fiddle::Function.new(
+    audio_handle["cohere_audio_ffmpeg_decode"],
+    [
+      Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_UINT64_T,
+      Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T
+    ],
+    Fiddle::TYPE_INT
+  )
+  cancel = Fiddle::Function.new(audio_handle["cohere_audio_ffmpeg_cancel"], [], Fiddle::TYPE_VOID)
+  release = Fiddle::Function.new(
+    audio_handle["cohere_audio_ffmpeg_free"],
+    [Fiddle::TYPE_VOIDP],
+    Fiddle::TYPE_VOID
+  )
+  Dir.mktmpdir("cohere-audio-smoke") do |temporary_directory|
+    fixture = File.join(temporary_directory, "fixture.wav")
+    frames = 400
+    pcm = Array.new(frames) { [16_384, -8_192] }.flatten.pack("s<*")
+    header = [
+      "RIFF", 36 + pcm.bytesize, "WAVE", "fmt ", 16, 1, 2,
+      16_000, 64_000, 4, 16, "data", pcm.bytesize
+    ].pack("a4Va4a4VvvVVvva4V")
+    File.binwrite(fixture, header + pcm)
+
+    duration_slot = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE, Fiddle::RUBY_FREE)
+    duration_slot[0, Fiddle::SIZEOF_DOUBLE] = [-1.0].pack("d")
+    status = duration.call(Fiddle::Pointer["#{fixture}\0"], duration_slot, diagnostic, 1_024)
+    raise "audio duration smoke failed: #{diagnostic}" unless status.zero?
+
+    seconds = duration_slot[0, Fiddle::SIZEOF_DOUBLE].unpack1("d")
+    raise "audio duration smoke mismatch: #{seconds}" unless (seconds - 0.025).abs <= 1e-9
+
+    output_slot = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP, Fiddle::RUBY_FREE)
+    output_slot[0, Fiddle::SIZEOF_VOIDP] = [0].pack("J")
+    count_slot = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT64_T, Fiddle::RUBY_FREE)
+    count_slot[0, Fiddle::SIZEOF_INT64_T] = [0].pack("q")
+    cancel.call # A previous cancellation must never poison a newly started operation.
+    status = decode.call(
+      Fiddle::Pointer["#{fixture}\0"], 16_000, frames * Fiddle::SIZEOF_FLOAT,
+      output_slot, count_slot, diagnostic, 1_024
+    )
+    address = output_slot[0, Fiddle::SIZEOF_VOIDP].unpack1("J")
+    count = count_slot[0, Fiddle::SIZEOF_INT64_T].unpack1("q")
+    begin
+      raise "audio decode smoke failed: #{diagnostic}" unless status.zero?
+      raise "audio decode smoke returned #{count} samples" unless count == frames && !address.zero?
+    ensure
+      release.call(address) unless address.zero?
+    end
+  end
+end
+
+puts "verified #{audio_symbols.length} audio ABI symbols in #{File.basename(audio_library)}: #{diagnostic}"

data/ext/cohere_transcribe_native/test/audio_matrix_smoke.cpp

@@ -0,0 +1,121 @@
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <dlfcn.h>
+#include <fstream>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#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;
+}
+
+template <typename Integer>
+void little_endian(std::ofstream& output, Integer value) {
+    for (std::size_t index = 0; index < sizeof(value); ++index) {
+        output.put(static_cast<char>((static_cast<std::uint64_t>(value) >> (8 * index)) & 0xff));
+    }
+}
+
+void write_fixture(const char* path) {
+    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::ofstream output(path, std::ios::binary | std::ios::trunc);
+    output.write("RIFF", 4);
+    little_endian(output, 36U + pcm_bytes);
+    output.write("WAVEfmt ", 8);
+    little_endian(output, 16U);
+    little_endian(output, static_cast<std::uint16_t>(1));
+    little_endian(output, channels);
+    little_endian(output, rate);
+    little_endian(output, static_cast<std::uint32_t>(rate * channels * sizeof(std::int16_t)));
+    little_endian(output, static_cast<std::uint16_t>(channels * sizeof(std::int16_t)));
+    little_endian(output, static_cast<std::uint16_t>(16));
+    output.write("data", 4);
+    little_endian(output, pcm_bytes);
+    for (std::uint32_t index = 0; index < frames; ++index) {
+        little_endian(output, static_cast<std::uint16_t>(16'384));
+        little_endian(output, static_cast<std::uint16_t>(-8'192));
+    }
+    if (!output)
+        throw std::runtime_error("could not write WAV fixture");
+}
+
+} // namespace
+
+int main(int argc, char** argv) try {
+    if (argc != 3)
+        throw std::runtime_error("usage: audio_matrix_smoke ADAPTER FIXTURE");
+    write_fixture(argv[2]);
+    void* library = dlopen(argv[1], RTLD_NOW | RTLD_LOCAL);
+    if (!library)
+        throw std::runtime_error(dlerror());
+
+    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 Free = void (*)(void*);
+    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 release = load<Free>(library, "cohere_audio_ffmpeg_free");
+
+    char diagnostic[1024] = {};
+    if (probe(diagnostic, sizeof(diagnostic)) != 0)
+        throw std::runtime_error(diagnostic);
+
+    float* invalid_samples = reinterpret_cast<float*>(static_cast<std::uintptr_t>(1));
+    std::int64_t invalid_count = 17;
+    if (decode(nullptr, 16'000, 0, &invalid_samples, &invalid_count,
+               diagnostic, sizeof(diagnostic)) != 2 || invalid_samples || invalid_count != 0) {
+        throw std::runtime_error("invalid decode did not clear output ownership metadata");
+    }
+    double invalid_duration = 17.0;
+    if (duration(nullptr, &invalid_duration, diagnostic, sizeof(diagnostic)) != 2 ||
+        invalid_duration != -1.0) {
+        throw std::runtime_error("invalid duration probe did not clear output metadata");
+    }
+    release(nullptr);
+
+    double seconds = -1.0;
+    std::int64_t count = 0;
+    for (int iteration = 0; iteration < 100; ++iteration) {
+        if (duration(argv[2], &seconds, diagnostic, sizeof(diagnostic)) != 0)
+            throw std::runtime_error(diagnostic);
+        if (std::abs(seconds - (400.0 / 16'000.0)) > 1e-9)
+            throw std::runtime_error("duration mismatch");
+
+        float* samples = nullptr;
+        count = 0;
+        const int status = decode(argv[2], 16'000, 400 * sizeof(float), &samples, &count,
+                                  diagnostic, sizeof(diagnostic));
+        if (status != 0) {
+            release(samples);
+            throw std::runtime_error(diagnostic);
+        }
+        if (!samples || count != 400 || !std::isfinite(samples[200])) {
+            release(samples);
+            throw std::runtime_error("decode output mismatch");
+        }
+        release(samples);
+    }
+    std::cout << diagnostic << " duration=" << seconds << " samples=" << count << '\n';
+    dlclose(library);
+    std::remove(argv[2]);
+    return 0;
+} catch (const std::exception& error) {
+    std::cerr << error.what() << '\n';
+    return 1;
+}