-module(viva_tensor).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/viva_tensor.gleam").
-export([zeros/1, ones/1, fill/2, from_list/1, from_list2d/1, vector/1, linspace/3, try_linspace/3, logspace/4, try_logspace/4, zeros_like/1, ones_like/1, full_like/2, eye/1, try_eye/1, identity/1, diag/1, try_diag/1, matrix/3, from_native_ref/2, native_ref/1, is_native/1, native_zeros/1, native_ones/1, native_fill/2, native_from_list/2, to_accelerated/1, to_rtx4090_fp16/1, to_rtx4090_fp32/1, gpu_workspace/0, workspace_zeros/2, workspace_from_tensor/2, linear_layer_fp16/2, linear_layer/3, random_uniform/1, random_normal/3, xavier_init/2, he_init/2, add/2, sub/2, mul/2, 'div'/2, add_into/3, sub_into/3, mul_into/3, scale/2, try_scale/2, scale_into/3, map/2, try_map/2, map2/3, softmax_axis/2, try_softmax_axis/2, sum/1, try_sum/1, mean/1, try_mean/1, product/1, try_product/1, cumsum/1, try_cumsum/1, cumprod/1, try_cumprod/1, cumsum_axis/2, try_cumsum_axis/2, cumprod_axis/2, try_cumprod_axis/2, median/1, try_median/1, percentile/2, try_percentile/2, sum_axis/2, sum_axis_keepdims/2, try_sum_axis/2, try_sum_axis_keepdims/2, mean_axis/2, mean_axis_keepdims/2, try_mean_axis/2, try_mean_axis_keepdims/2, max_axis/2, max_axis_keepdims/2, try_max_axis/2, try_max_axis_keepdims/2, min_axis/2, min_axis_keepdims/2, try_min_axis/2, try_min_axis_keepdims/2, max/1, try_max/1, min/1, try_min/1, argmax/1, try_argmax/1, argmin/1, try_argmin/1, variance/1, try_variance/1, std/1, try_std/1, dot/2, matmul/2, detect_backends/0, capabilities/0, plan_backend/1, matmul_planned/2, matmul_auto/2, matmul_accelerated/2, matmul_accelerated_into/3, matmul_relu_accelerated_into/3, matmul_gelu_accelerated_into/3, linear_relu_accelerated_into/4, linear_gelu_accelerated_into/4, linear_output/3, linear_relu_forward_into/3, linear_gelu_forward_into/3, accelerated_to_tensor/1, accelerated_backend/1, accelerated_shape/1, accelerated_sync/0, workspace_backend/1, linear_layer_backend/1, linear_layer_input_features/1, linear_layer_output_features/1, matmul_into/3, linear_relu/3, linear_relu_into/4, matmul_vec/2, transpose/1, outer/2, einsum/2, solve/2, inv/1, det/1, lu/1, cholesky/1, qr/1, svd/1, eig/1, reshape/2, flatten/1, try_flatten/1, squeeze/1, unsqueeze/2, try_unsqueeze/2, take_flat/2, try_take_flat/2, try_take/2, take/3, gather/2, mask_select/2, nonzero_flat/1, try_nonzero_flat/1, try_nonzero/1, nonzero/1, masked_select/2, try_masked_select/2, embedding_init/2, embedding_init_uniform/2, embedding_forward/2, sinusoidal_encoding/2, learned_positional_init/2, learned_positional_forward/2, rope/2, shape/1, size/1, rank/1, layout/1, device/1, dtype/1, to_list/1, try_to_list/1, default_print_options/0, to_string/1, to_string_with/2, inspect/1, accelerated_to_string/1, accelerated_to_string_with/2, safetensors_read/1, safetensors_write/2, onnx_parse_graph/1, onnx_run_graph/2, onnx_supported_ops/0, norm/1, try_norm/1, normalize/1, try_normalize/1, is_close/4, all_close/4, abs/1, try_abs/1, square/1, try_square/1, sqrt/1, try_sqrt/1, exp/1, try_exp/1, log/1, try_log/1, floor/1, try_floor/1, ceil/1, try_ceil/1, round/1, try_round/1, sign/1, try_sign/1, reciprocal/1, try_reciprocal/1, euclidean_distance/2, try_euclidean_distance/2, manhattan_distance/2, try_manhattan_distance/2, cosine_similarity/2, try_cosine_similarity/2, dot_similarity/2, try_dot_similarity/2, zscore/1, try_zscore/1, standardize/1, try_standardize/1, minmax_scale/3, try_minmax_scale/3, clip_by_norm/2, try_clip_by_norm/2, add_scalar/2, try_add_scalar/2, negate/1, try_negate/1, clamp/3, try_clamp/3, clip/3, try_clip/3, can_broadcast/2, broadcast_shape/2, broadcast_shapes/1, broadcast_to/2, broadcast_pair/2, add_broadcast/2, sub_broadcast/2, mul_broadcast/2, div_broadcast/2, maximum/2, try_maximum/2, minimum/2, try_minimum/2, equal/2, try_equal/2, not_equal/2, try_not_equal/2, greater/2, try_greater/2, greater_equal/2, try_greater_equal/2, less/2, try_less/2, less_equal/2, try_less_equal/2, where/3, try_where/3, logical_not/1, try_logical_not/1, logical_and/2, try_logical_and/2, logical_or/2, try_logical_or/2, logical_xor/2, try_logical_xor/2, any/1, try_any/1, all/1, try_all/1, count_nonzero/1, try_count_nonzero/1, any_axis/2, try_any_axis/2, any_axis_keepdims/2, try_any_axis_keepdims/2, all_axis/2, try_all_axis/2, all_axis_keepdims/2, try_all_axis_keepdims/2, count_nonzero_axis/2, try_count_nonzero_axis/2, count_nonzero_axis_keepdims/2, try_count_nonzero_axis_keepdims/2, to_strided/1, try_to_strided/1, to_contiguous/1, try_to_contiguous/1, transpose_strided/1, is_contiguous/1, layer_norm_init/1, layer_norm_init_with_eps/2, layer_norm_forward/2, rms_norm_init/1, rms_norm_init_with_eps/2, rms_norm_forward/2, batch_norm_1d_init/1, batch_norm_1d_forward/3, group_norm_init/2, group_norm_forward/2, conv2d_config/0, conv2d_same/2, conv2d/3, pad2d/3, pad4d/3, max_pool2d/5, avg_pool2d/5, conv1d_init/5, conv1d_forward/2, conv3d_init/5, conv3d_forward/2, conv_transpose_2d_init/6, conv_transpose_2d_forward/2, global_avg_pool2d/1, dropout_init/1, dropout_forward/3, max_pool_1d_forward/2, avg_pool_1d_forward/2, adaptive_avg_pool_2d_forward/2, adaptive_avg_pool_1d_forward/2, upsample_forward/2, max_pool_2d_with_indices/4, max_unpool_2d_forward/4, nms/3, roi_align/3, batched_matmul/2, batch_norm_2d_init/1, batch_norm_2d_forward/3, measure_tflops/4, measure_tflops_averaged/5, backend_capabilities/0, hardware_profiles/0, nvfp4_block_scaled_layout/1, int2_progressive_layout/2, int3_progressive_layout/2, quant_layout_memory_bytes/1, quant_layout_compression_ratio_against/2, quant_layout_is_rubin_native_candidate/1, try_hadamard_preprocess/2, try_inverse_hadamard_preprocess/1, try_normalized_walsh_hadamard/1, tensor_spec/1, spec_from_parts/5, dtype_name/1, device_name/1, spec_key/1, plan_runtime/2, runtime_cache_key/1, cache_key/1, mse_loss/3, l1_loss/3, bce_loss/3, cross_entropy_loss/3, huber_loss/4, sgd/1, sgd_momentum/2, rmsprop/3, adam/1, adamw/2, step/3, zero_grad/1, sigmoid/1, tanh/1, relu/1, leaky_relu/2, elu/2, selu/1, gelu/1, swish/1, mish/1, softplus/1, softmax/2, log_softmax/2, hardswish/1, hardtanh/3, relu_backward/2, sigmoid_backward/2, tanh_backward/2, gelu_backward/2, leaky_relu_backward/3, elu_backward/3, mse_loss_backward/4, l1_loss_backward/4, bce_loss_backward/4, cross_entropy_loss_backward/4, linear_backward/3, matmul_backward/3, layer_norm_backward/6, rms_norm_backward/5, softmax_backward/3, scaled_dot_product_attention/5, multi_head_attention_init/3, multi_head_attention_forward/5, causal_mask/1, rnn_cell_init/2, gru_cell_init/2, lstm_cell_init/2, rnn_cell_step/3, gru_cell_step/3, lstm_cell_step/4, rnn_sequence/3, gru_sequence/3, lstm_sequence/4, dataset_from_samples/1, dataset_from_lists/2, dataset_len/1, dataset_get/2, data_loader_new/4, data_loader_batches/1, data_loader_len/1, step_lr/3, cosine_annealing_lr/3, linear_warmup/2, one_cycle_lr/4, exponential_lr/2, scheduler_step/1, scheduler_lr/1, apply_to_optimizer/2, whitespace_tokenizer_from_vocab/3, whitespace_encode/2, whitespace_decode/2, char_tokenizer_from_alphabet/2, char_encode/2, char_decode/2, word_piece_tokenizer_from_vocab/5, word_piece_encode/2, word_piece_decode/2, bpe_tokenizer_from_vocab_and_merges/3, bpe_encode/2, bpe_decode/2, unigram_tokenizer_from_pieces/4, unigram_encode/2, unigram_decode/2, sentence_piece_unigram/1, sentence_piece_bpe/1, sentence_piece_encode/2, sentence_piece_decode/2, ids_to_tensor/1, tensor_to_ids/1, pad_or_truncate/3, accuracy/2, confusion_matrix/3, precision/4, recall/4, f1/4, top_k_accuracy/3, iou_per_class/3, mean_iou/3, mean_absolute_error/2, mean_squared_error/2, root_mean_squared_error/2, r_squared/2, mean_absolute_percentage_error/2, init_zeros/1, init_ones/1, init_constant/2, init_identity/1, uniform/3, normal/3, truncated_normal/5, xavier_uniform/2, xavier_normal/2, kaiming_uniform/3, kaiming_normal/3, orthogonal/3, relu_gain/0, leaky_relu_gain/1, tanh_gain/0, linear_gain/0, sigmoid_gain/0, feed_forward_init/3, feed_forward_forward/2, encoder_block_init/4, encoder_block_forward/3, decoder_block_init/4, decoder_block_forward/3, transformer_init/6, transformer_encode/2, transformer_decode/3, transformer_forward/3, vision_resize/4, vision_center_crop/3, vision_random_crop/3, vision_horizontal_flip/1, vision_vertical_flip/1, vision_random_horizontal_flip/2, vision_normalize/3, vision_to_grayscale/2, vision_adjust_brightness/2, vision_adjust_contrast/2, vision_to_tensor/4, vision_to_byte_image/1, vision_compose/2, load_safetensors_dict/1, load_embedding/4, load_layer_norm/3, load_multi_head_attention/4, load_feed_forward/5, load_encoder_block/6, load_transformer/7, from_safetensors_file/2, color_jitter_init/4, color_jitter_forward/2, mixup/4, cutmix/4, build_schedule/1, ddpm_step/4, ddim_step/5, sample/4, traced_relu/2, traced_sigmoid/2, traced_tanh/2, traced_gelu/2, traced_softmax/3, traced_matmul/3, traced_linear/3, traced_add/3, traced_sub/3, traced_mul/3, traced_scale/3, traced_layer_norm/5, traced_mse_loss/3, traced_l1_loss/3, router_init/3, router_route/2, moe_block_init/4, moe_block_forward/2, compute_load_balance_loss/3, expert_distribution/3, llama_block_init/3, llama_block_forward/2, llama_model_init/5, llama_model_forward/2, bert_embedding_init/4, bert_embedding_forward/3, bert_block_init/3, bert_block_forward/2, bert_model_init/6, bert_model_forward/3, gpt_block_init/3, gpt_block_forward/2, gpt_model_init/6, gpt_model_forward/2, t5_encoder_block_init/3, t5_decoder_block_init/3, t5_encoder_block_forward/2, t5_decoder_block_forward/3, t5_model_init/6, t5_model_forward/3, distribute_grads/2, synchronous_train_step/4, train_synchronous/6, greedy_sample/1, sample_token/2, apply_temperature/2, top_k_filter/2, top_p_filter/2, speculative_decode/4, greedy_generate/4, load_model/1, generate/3, default_generate_opts/0, prepack_fp8_weight/1, prepack_int8_sparse_24_weight/1, prepack_int4_sparse_24_weight/1, linear_fp8/3, linear_int4_sparse/3, linear_int8_sparse/3, linear_gelu_fp8/3, linear_swiglu_fp8/4]).
-export_type([tensor_storage/0, tensor_device/0, tensor_dtype/0, tensor_memory_layout/0, tensor_spec/0, backend_device/0, backend_dtype/0, tensor_backend/0, tensor_operation/0, backend_operation/0, backend_capability/0, backend_rejection/0, tensor_backend_plan/0, runtime_op/0, runtime_rejection/0, runtime_plan/0, tensor_capabilities/0, model_handle/0, generate_top_k/0, generate_opts/0, generation/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " High-performance tensor operations for Gleam on the BEAM.\n"
    "\n"
    " This module is the stable entry point for the package. It exposes the\n"
    " tensor type, common constructors, shape operations, linear algebra,\n"
    " element-wise math, reductions, native acceleration helpers, and layout\n"
    " inspection.\n"
    "\n"
    " Lower-level implementation, backend, neural-network, quantization, sparse,\n"
    " telemetry, and benchmark modules are intentionally excluded from the public\n"
    " documentation until their contracts are stable. The related\n"
    " `viva_tensor/layout`, `viva_tensor/axis`, and `viva_tensor/named` modules\n"
    " are public when callers need explicit layout metadata or named dimensions.\n"
    "\n"
    " ```gleam\n"
    " import gleam/result\n"
    " import viva_tensor as t\n"
    "\n"
    " let a = t.zeros([2, 3])\n"
    " let b = t.ones([2, 3])\n"
    " use c <- result.try(t.add(a, b))\n"
    " c\n"
    " ```\n"
).

-type tensor_storage() :: dense_storage | strided_storage | native_storage.

-type tensor_device() :: beam_cpu | native_cpu | {cuda_device, integer()}.

-type tensor_dtype() :: float64 |
    float32 |
    float16 |
    b_float16 |
    float8_e4_m3 |
    int8 |
    int4 |
    sparse_float16.

-type tensor_memory_layout() :: row_major |
    column_major |
    strided_layout |
    packed_fp8_layout |
    packed_sparse24_layout.

-type tensor_spec() :: {tensor_spec,
        list(integer()),
        tensor_dtype(),
        tensor_device(),
        tensor_storage(),
        tensor_memory_layout(),
        integer(),
        integer()}.

-type backend_device() :: backend_beam_cpu | backend_native_cpu | backend_cuda.

-type backend_dtype() :: backend_float64 |
    backend_float32 |
    backend_float16 |
    backend_int8 |
    backend_sparse_float16.

-type tensor_backend() :: backend_pure_gleam |
    backend_zig_simd |
    backend_mkl |
    backend_cuda_fp32 |
    backend_cuda_fp16 |
    backend_cuda_int8 |
    backend_cuda_sparse.

-type tensor_operation() :: operation_elementwise |
    operation_broadcast |
    operation_reduction |
    operation_softmax |
    {operation_matmul, integer(), integer(), integer()}.

-type backend_operation() :: backend_elementwise |
    backend_broadcast |
    backend_reduction |
    backend_softmax |
    backend_matmul.

-type backend_capability() :: {backend_capability,
        tensor_backend(),
        boolean(),
        backend_device(),
        list(backend_dtype()),
        list(backend_operation()),
        binary()}.

-type backend_rejection() :: {backend_rejection, tensor_backend(), binary()}.

-type tensor_backend_plan() :: {tensor_backend_plan,
        tensor_operation(),
        tensor_backend(),
        list(tensor_backend()),
        list(backend_rejection()),
        binary()}.

-type runtime_op() :: runtime_elementwise |
    runtime_broadcast |
    runtime_reduction |
    runtime_softmax |
    {runtime_matmul, integer(), integer(), integer()} |
    {runtime_linear, integer(), integer(), integer()}.

-type runtime_rejection() :: {runtime_rejection, tensor_backend(), binary()}.

-type runtime_plan() :: {runtime_plan,
        tensor_spec(),
        runtime_op(),
        tensor_backend(),
        list(tensor_backend()),
        list(runtime_rejection()),
        binary(),
        binary()}.

-type tensor_capabilities() :: {tensor_capabilities,
        boolean(),
        boolean(),
        binary(),
        list(viva_tensor@native@tflops:backend()),
        list(backend_capability())}.

-type model_handle() :: any().

-type generate_top_k() :: top_k_infinity | {top_k, integer()}.

-type generate_opts() :: {generate_opts,
        integer(),
        float(),
        generate_top_k(),
        float(),
        integer(),
        boolean()}.

-type generation() :: {generation,
        list(integer()),
        binary(),
        float(),
        integer()}.

-file("src/viva_tensor.gleam", 386).
?DOC(" Create a tensor filled with zeros.\n").
-spec zeros(list(integer())) -> viva_tensor@tensor:tensor().
zeros(Shape) ->
    viva_tensor@tensor:zeros(Shape).

-file("src/viva_tensor.gleam", 391).
?DOC(" Create tensor of ones\n").
-spec ones(list(integer())) -> viva_tensor@tensor:tensor().
ones(Shape) ->
    viva_tensor@tensor:ones(Shape).

-file("src/viva_tensor.gleam", 396).
?DOC(" Create tensor filled with value\n").
-spec fill(list(integer()), float()) -> viva_tensor@tensor:tensor().
fill(Shape, Value) ->
    viva_tensor@tensor:fill(Shape, Value).

-file("src/viva_tensor.gleam", 401).
?DOC(" Create tensor from list (1D)\n").
-spec from_list(list(float())) -> viva_tensor@tensor:tensor().
from_list(Data) ->
    viva_tensor@tensor:from_list(Data).

-file("src/viva_tensor.gleam", 406).
?DOC(" Create 2D tensor from list of lists\n").
-spec from_list2d(list(list(float()))) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
from_list2d(Rows) ->
    viva_tensor@tensor:from_list2d(Rows).

-file("src/viva_tensor.gleam", 411).
?DOC(" Create vector (1D tensor)\n").
-spec vector(list(float())) -> viva_tensor@tensor:tensor().
vector(Data) ->
    viva_tensor@tensor:vector(Data).

-file("src/viva_tensor.gleam", 416).
?DOC(" Create a 1D tensor with evenly spaced values over a closed interval.\n").
-spec linspace(float(), float(), integer()) -> viva_tensor@tensor:tensor().
linspace(Start, Stop, Steps) ->
    viva_tensor@tensor:linspace(Start, Stop, Steps).

-file("src/viva_tensor.gleam", 421).
?DOC(" Create a 1D tensor with evenly spaced values over a closed interval.\n").
-spec try_linspace(float(), float(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_linspace(Start, Stop, Steps) ->
    viva_tensor@tensor:try_linspace(Start, Stop, Steps).

-file("src/viva_tensor.gleam", 430).
?DOC(" Create a 1D tensor with logarithmically spaced values.\n").
-spec logspace(float(), float(), integer(), float()) -> viva_tensor@tensor:tensor().
logspace(Start, Stop, Steps, Base) ->
    viva_tensor@tensor:logspace(Start, Stop, Steps, Base).

-file("src/viva_tensor.gleam", 435).
?DOC(" Create a 1D tensor with logarithmically spaced values.\n").
-spec try_logspace(float(), float(), integer(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_logspace(Start, Stop, Steps, Base) ->
    viva_tensor@tensor:try_logspace(Start, Stop, Steps, Base).

-file("src/viva_tensor.gleam", 445).
?DOC(" Create a tensor with the same shape as another tensor, filled with zeros.\n").
-spec zeros_like(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
zeros_like(T) ->
    viva_tensor@tensor:zeros_like(T).

-file("src/viva_tensor.gleam", 450).
?DOC(" Create a tensor with the same shape as another tensor, filled with ones.\n").
-spec ones_like(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
ones_like(T) ->
    viva_tensor@tensor:ones_like(T).

-file("src/viva_tensor.gleam", 455).
?DOC(" Create a tensor with the same shape as another tensor, filled with a value.\n").
-spec full_like(viva_tensor@tensor:tensor(), float()) -> viva_tensor@tensor:tensor().
full_like(T, Value) ->
    viva_tensor@tensor:full_like(T, Value).

-file("src/viva_tensor.gleam", 460).
?DOC(" Create a square identity matrix.\n").
-spec eye(integer()) -> viva_tensor@tensor:tensor().
eye(N) ->
    viva_tensor@tensor:eye(N).

-file("src/viva_tensor.gleam", 465).
?DOC(" Create a square identity matrix.\n").
-spec try_eye(integer()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_eye(N) ->
    viva_tensor@tensor:try_eye(N).

-file("src/viva_tensor.gleam", 470).
?DOC(" Alias for `eye`.\n").
-spec identity(integer()) -> viva_tensor@tensor:tensor().
identity(N) ->
    viva_tensor@tensor:identity(N).

-file("src/viva_tensor.gleam", 475).
?DOC(" Create a square diagonal matrix from a 1D tensor.\n").
-spec diag(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
diag(T) ->
    viva_tensor@tensor:diag(T).

-file("src/viva_tensor.gleam", 480).
?DOC(" Create a square diagonal matrix from a 1D tensor.\n").
-spec try_diag(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_diag(T) ->
    viva_tensor@tensor:try_diag(T).

-file("src/viva_tensor.gleam", 485).
?DOC(" Create matrix (2D tensor)\n").
-spec matrix(integer(), integer(), list(float())) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matrix(Rows, Cols, Data) ->
    viva_tensor@tensor:matrix(Rows, Cols, Data).

-file("src/viva_tensor.gleam", 494).
?DOC(" Wrap an existing native NIF tensor resource.\n").
-spec from_native_ref(viva_tensor@core@ffi:native_tensor_ref(), list(integer())) -> viva_tensor@tensor:tensor().
from_native_ref(Ref, Shape) ->
    viva_tensor@tensor:from_native_ref(Ref, Shape).

-file("src/viva_tensor.gleam", 499).
?DOC(" Extract the native NIF tensor resource when present.\n").
-spec native_ref(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@core@ffi:native_tensor_ref()} |
    {error, nil}.
native_ref(T) ->
    viva_tensor@tensor:native_ref(T).

-file("src/viva_tensor.gleam", 504).
?DOC(" Check whether a tensor is backed by native NIF memory.\n").
-spec is_native(viva_tensor@tensor:tensor()) -> boolean().
is_native(T) ->
    viva_tensor@tensor:is_native(T).

-file("src/viva_tensor.gleam", 509).
?DOC(" Create a native-backed tensor of zeros.\n").
-spec native_zeros(list(integer())) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
native_zeros(Shape) ->
    viva_tensor@tensor:native_zeros(Shape).

-file("src/viva_tensor.gleam", 514).
?DOC(" Create a native-backed tensor of ones.\n").
-spec native_ones(list(integer())) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
native_ones(Shape) ->
    viva_tensor@tensor:native_ones(Shape).

-file("src/viva_tensor.gleam", 519).
?DOC(" Create a native-backed tensor filled with a value.\n").
-spec native_fill(list(integer()), float()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
native_fill(Shape, Value) ->
    viva_tensor@tensor:native_fill(Shape, Value).

-file("src/viva_tensor.gleam", 527).
?DOC(" Create a native-backed tensor from row-major list data.\n").
-spec native_from_list(list(float()), list(integer())) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
native_from_list(Data, Shape) ->
    viva_tensor@tensor:native_from_list(Data, Shape).

-file("src/viva_tensor.gleam", 535).
?DOC(" Move a tensor to the best persistent backend: RTX 4090 first, then MKL/CPU.\n").
-spec to_accelerated(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@native@cuda:accelerated_tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
to_accelerated(T) ->
    viva_tensor@native@cuda:to_accelerated(T).

-file("src/viva_tensor.gleam", 540).
?DOC(" Upload a tensor to persistent RTX 4090 FP16 memory.\n").
-spec to_rtx4090_fp16(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@native@cuda:accelerated_tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
to_rtx4090_fp16(T) ->
    viva_tensor@native@cuda:to_rtx4090_fp16(T).

-file("src/viva_tensor.gleam", 545).
?DOC(" Upload a tensor to persistent RTX 4090 FP32 memory.\n").
-spec to_rtx4090_fp32(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@native@cuda:accelerated_tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
to_rtx4090_fp32(T) ->
    viva_tensor@native@cuda:to_rtx4090_fp32(T).

-file("src/viva_tensor.gleam", 550).
?DOC(" Create an RTX 4090 FP16 workspace.\n").
-spec gpu_workspace() -> {ok, viva_tensor@native@cuda:gpu_workspace()} |
    {error, viva_tensor@core@error:tensor_error()}.
gpu_workspace() ->
    viva_tensor@native@cuda:gpu_workspace().

-file("src/viva_tensor.gleam", 555).
?DOC(" Allocate a reusable zero-filled output buffer in workspace memory.\n").
-spec workspace_zeros(viva_tensor@native@cuda:gpu_workspace(), list(integer())) -> {ok,
        viva_tensor@native@cuda:accelerated_tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
workspace_zeros(Workspace, Shape) ->
    viva_tensor@native@cuda:workspace_zeros(Workspace, Shape).

-file("src/viva_tensor.gleam", 563).
?DOC(" Move a tensor into workspace memory.\n").
-spec workspace_from_tensor(
    viva_tensor@native@cuda:gpu_workspace(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@native@cuda:accelerated_tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
workspace_from_tensor(Workspace, Tensor) ->
    viva_tensor@native@cuda:workspace_from_tensor(Workspace, Tensor).

-file("src/viva_tensor.gleam", 571).
?DOC(" Create a persisted FP16 linear layer on the RTX.\n").
-spec linear_layer_fp16(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@native@cuda:linear_layer()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_layer_fp16(Weight, Bias) ->
    viva_tensor@native@cuda:linear_layer_fp16(Weight, Bias).

-file("src/viva_tensor.gleam", 579).
?DOC(" Create a persisted linear layer in workspace memory.\n").
-spec linear_layer(
    viva_tensor@native@cuda:gpu_workspace(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@native@cuda:linear_layer()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_layer(Workspace, Weight, Bias) ->
    viva_tensor@native@cuda:linear_layer(Workspace, Weight, Bias).

-file("src/viva_tensor.gleam", 590).
?DOC(" Random uniform [0, 1)\n").
-spec random_uniform(list(integer())) -> viva_tensor@tensor:tensor().
random_uniform(Shape) ->
    viva_tensor@tensor:random_uniform(Shape).

-file("src/viva_tensor.gleam", 595).
?DOC(" Tensor with normal random values\n").
-spec random_normal(list(integer()), float(), float()) -> viva_tensor@tensor:tensor().
random_normal(Shape, Mean, Std) ->
    viva_tensor@tensor:random_normal(Shape, Mean, Std).

-file("src/viva_tensor.gleam", 600).
?DOC(" Xavier initialization for neural network weights\n").
-spec xavier_init(integer(), integer()) -> viva_tensor@tensor:tensor().
xavier_init(Fan_in, Fan_out) ->
    viva_tensor@tensor:xavier_init(Fan_in, Fan_out).

-file("src/viva_tensor.gleam", 605).
?DOC(" He initialization (for ReLU networks)\n").
-spec he_init(integer(), integer()) -> viva_tensor@tensor:tensor().
he_init(Fan_in, Fan_out) ->
    viva_tensor@tensor:he_init(Fan_in, Fan_out).

-file("src/viva_tensor.gleam", 612).
?DOC(" Add element-wise\n").
-spec add(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
add(A, B) ->
    viva_tensor@tensor:add(A, B).

-file("src/viva_tensor.gleam", 617).
?DOC(" Element-wise subtraction\n").
-spec sub(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
sub(A, B) ->
    viva_tensor@tensor:sub(A, B).

-file("src/viva_tensor.gleam", 622).
?DOC(" Element-wise multiplication\n").
-spec mul(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
mul(A, B) ->
    viva_tensor@tensor:mul(A, B).

-file("src/viva_tensor.gleam", 627).
?DOC(" Element-wise division\n").
-spec 'div'(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
'div'(A, B) ->
    viva_tensor@tensor:'div'(A, B).

-file("src/viva_tensor.gleam", 632).
?DOC(" Write out = a + b into a preallocated native tensor.\n").
-spec add_into(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
add_into(Out, A, B) ->
    viva_tensor@tensor:add_into(Out, A, B).

-file("src/viva_tensor.gleam", 637).
?DOC(" Write out = a - b into a preallocated native tensor.\n").
-spec sub_into(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
sub_into(Out, A, B) ->
    viva_tensor@tensor:sub_into(Out, A, B).

-file("src/viva_tensor.gleam", 642).
?DOC(" Write out = a * b into a preallocated native tensor.\n").
-spec mul_into(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
mul_into(Out, A, B) ->
    viva_tensor@tensor:mul_into(Out, A, B).

-file("src/viva_tensor.gleam", 647).
?DOC(" Scale by constant\n").
-spec scale(viva_tensor@tensor:tensor(), float()) -> viva_tensor@tensor:tensor().
scale(T, S) ->
    viva_tensor@tensor:scale(T, S).

-file("src/viva_tensor.gleam", 652).
?DOC(" Scale by constant, preserving materialization failures.\n").
-spec try_scale(viva_tensor@tensor:tensor(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_scale(T, S) ->
    viva_tensor@tensor:try_scale(T, S).

-file("src/viva_tensor.gleam", 657).
?DOC(" Write out = a * scalar into a preallocated native tensor.\n").
-spec scale_into(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    float()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
scale_into(Out, A, Scalar) ->
    viva_tensor@tensor:scale_into(Out, A, Scalar).

-file("src/viva_tensor.gleam", 666).
?DOC(" Apply function to each element\n").
-spec map(viva_tensor@tensor:tensor(), fun((float()) -> float())) -> viva_tensor@tensor:tensor().
map(T, F) ->
    viva_tensor@tensor:map(T, F).

-file("src/viva_tensor.gleam", 671).
?DOC(" Apply function to each element, preserving materialization failures.\n").
-spec try_map(viva_tensor@tensor:tensor(), fun((float()) -> float())) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_map(T, F) ->
    viva_tensor@tensor:try_map(T, F).

-file("src/viva_tensor.gleam", 679).
?DOC(" Apply a binary function element-wise over tensors with the same shape.\n").
-spec map2(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    fun((float(), float()) -> float())
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
map2(A, B, F) ->
    viva_tensor@tensor:map2(A, B, F).

-file("src/viva_tensor.gleam", 688).
?DOC(" Softmax along one axis, preserving shape and normalizing each slice.\n").
-spec softmax_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
softmax_axis(T, Axis) ->
    viva_tensor@tensor:softmax_axis(T, Axis).

-file("src/viva_tensor.gleam", 693).
?DOC(" Softmax along one axis, preserving materialization failures.\n").
-spec try_softmax_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_softmax_axis(T, Axis) ->
    viva_tensor@tensor:try_softmax_axis(T, Axis).

-file("src/viva_tensor.gleam", 700).
?DOC(" Sum everything\n").
-spec sum(viva_tensor@tensor:tensor()) -> float().
sum(T) ->
    viva_tensor@tensor:sum(T).

-file("src/viva_tensor.gleam", 705).
?DOC(" Sum everything, preserving materialization failures.\n").
-spec try_sum(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_sum(T) ->
    viva_tensor@tensor:try_sum(T).

-file("src/viva_tensor.gleam", 710).
?DOC(" Mean of all elements\n").
-spec mean(viva_tensor@tensor:tensor()) -> float().
mean(T) ->
    viva_tensor@tensor:mean(T).

-file("src/viva_tensor.gleam", 715).
?DOC(" Mean of all elements, preserving materialization and empty-tensor errors.\n").
-spec try_mean(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_mean(T) ->
    viva_tensor@tensor:try_mean(T).

-file("src/viva_tensor.gleam", 720).
?DOC(" Product of all elements.\n").
-spec product(viva_tensor@tensor:tensor()) -> float().
product(T) ->
    viva_tensor@tensor:product(T).

-file("src/viva_tensor.gleam", 725).
?DOC(" Product of all elements, preserving materialization failures.\n").
-spec try_product(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_product(T) ->
    viva_tensor@tensor:try_product(T).

-file("src/viva_tensor.gleam", 730).
?DOC(" Cumulative sum over the flattened tensor, preserving the original shape.\n").
-spec cumsum(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
cumsum(T) ->
    viva_tensor@tensor:cumsum(T).

-file("src/viva_tensor.gleam", 735).
?DOC(" Cumulative sum over the flattened tensor, preserving materialization failures.\n").
-spec try_cumsum(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_cumsum(T) ->
    viva_tensor@tensor:try_cumsum(T).

-file("src/viva_tensor.gleam", 740).
?DOC(" Cumulative product over the flattened tensor, preserving the original shape.\n").
-spec cumprod(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
cumprod(T) ->
    viva_tensor@tensor:cumprod(T).

-file("src/viva_tensor.gleam", 745).
?DOC(" Cumulative product over the flattened tensor, preserving materialization failures.\n").
-spec try_cumprod(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_cumprod(T) ->
    viva_tensor@tensor:try_cumprod(T).

-file("src/viva_tensor.gleam", 750).
?DOC(" Cumulative sum along one axis, preserving the original shape.\n").
-spec cumsum_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
cumsum_axis(T, Axis) ->
    viva_tensor@tensor:cumsum_axis(T, Axis).

-file("src/viva_tensor.gleam", 755).
?DOC(" Cumulative sum along one axis, preserving materialization failures.\n").
-spec try_cumsum_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_cumsum_axis(T, Axis) ->
    viva_tensor@tensor:try_cumsum_axis(T, Axis).

-file("src/viva_tensor.gleam", 760).
?DOC(" Cumulative product along one axis, preserving the original shape.\n").
-spec cumprod_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
cumprod_axis(T, Axis) ->
    viva_tensor@tensor:cumprod_axis(T, Axis).

-file("src/viva_tensor.gleam", 765).
?DOC(" Cumulative product along one axis, preserving materialization failures.\n").
-spec try_cumprod_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_cumprod_axis(T, Axis) ->
    viva_tensor@tensor:try_cumprod_axis(T, Axis).

-file("src/viva_tensor.gleam", 770).
?DOC(" Median value.\n").
-spec median(viva_tensor@tensor:tensor()) -> float().
median(T) ->
    viva_tensor@tensor:median(T).

-file("src/viva_tensor.gleam", 775).
?DOC(" Median value, preserving materialization and empty-tensor errors.\n").
-spec try_median(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_median(T) ->
    viva_tensor@tensor:try_median(T).

-file("src/viva_tensor.gleam", 780).
?DOC(" Percentile using linear interpolation between closest ranks.\n").
-spec percentile(viva_tensor@tensor:tensor(), integer()) -> float().
percentile(T, Percentile) ->
    viva_tensor@tensor:percentile(T, Percentile).

-file("src/viva_tensor.gleam", 785).
?DOC(" Percentile using linear interpolation between closest ranks.\n").
-spec try_percentile(viva_tensor@tensor:tensor(), integer()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_percentile(T, Percentile) ->
    viva_tensor@tensor:try_percentile(T, Percentile).

-file("src/viva_tensor.gleam", 793).
?DOC(" Sum along one axis.\n").
-spec sum_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
sum_axis(T, Axis) ->
    viva_tensor@tensor:sum_axis(T, Axis).

-file("src/viva_tensor.gleam", 798).
?DOC(" Sum along one axis, preserving the reduced dimension as size 1.\n").
-spec sum_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
sum_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:sum_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 803).
?DOC(" Sum along one axis, preserving materialization failures.\n").
-spec try_sum_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_sum_axis(T, Axis) ->
    viva_tensor@tensor:try_sum_axis(T, Axis).

-file("src/viva_tensor.gleam", 808).
?DOC(" Sum along one axis with keepdims, preserving materialization failures.\n").
-spec try_sum_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_sum_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:try_sum_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 816).
?DOC(" Mean along one axis.\n").
-spec mean_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
mean_axis(T, Axis) ->
    viva_tensor@tensor:mean_axis(T, Axis).

-file("src/viva_tensor.gleam", 821).
?DOC(" Mean along one axis, preserving the reduced dimension as size 1.\n").
-spec mean_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
mean_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:mean_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 826).
?DOC(" Mean along one axis, preserving materialization failures.\n").
-spec try_mean_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_mean_axis(T, Axis) ->
    viva_tensor@tensor:try_mean_axis(T, Axis).

-file("src/viva_tensor.gleam", 831).
?DOC(" Mean along one axis with keepdims, preserving materialization failures.\n").
-spec try_mean_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_mean_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:try_mean_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 839).
?DOC(" Maximum along one axis.\n").
-spec max_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
max_axis(T, Axis) ->
    viva_tensor@tensor:max_axis(T, Axis).

-file("src/viva_tensor.gleam", 844).
?DOC(" Maximum along one axis, preserving the reduced dimension as size 1.\n").
-spec max_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
max_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:max_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 849).
?DOC(" Maximum along one axis, preserving materialization failures.\n").
-spec try_max_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_max_axis(T, Axis) ->
    viva_tensor@tensor:try_max_axis(T, Axis).

-file("src/viva_tensor.gleam", 854).
?DOC(" Maximum along one axis with keepdims, preserving materialization failures.\n").
-spec try_max_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_max_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:try_max_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 862).
?DOC(" Minimum along one axis.\n").
-spec min_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
min_axis(T, Axis) ->
    viva_tensor@tensor:min_axis(T, Axis).

-file("src/viva_tensor.gleam", 867).
?DOC(" Minimum along one axis, preserving the reduced dimension as size 1.\n").
-spec min_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
min_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:min_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 872).
?DOC(" Minimum along one axis, preserving materialization failures.\n").
-spec try_min_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_min_axis(T, Axis) ->
    viva_tensor@tensor:try_min_axis(T, Axis).

-file("src/viva_tensor.gleam", 877).
?DOC(" Minimum along one axis with keepdims, preserving materialization failures.\n").
-spec try_min_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_min_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:try_min_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 885).
?DOC(" Maximum value\n").
-spec max(viva_tensor@tensor:tensor()) -> float().
max(T) ->
    viva_tensor@tensor:max(T).

-file("src/viva_tensor.gleam", 890).
?DOC(" Maximum value, preserving materialization and empty-tensor errors.\n").
-spec try_max(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_max(T) ->
    viva_tensor@tensor:try_max(T).

-file("src/viva_tensor.gleam", 895).
?DOC(" Minimum value\n").
-spec min(viva_tensor@tensor:tensor()) -> float().
min(T) ->
    viva_tensor@tensor:min(T).

-file("src/viva_tensor.gleam", 900).
?DOC(" Minimum value, preserving materialization and empty-tensor errors.\n").
-spec try_min(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_min(T) ->
    viva_tensor@tensor:try_min(T).

-file("src/viva_tensor.gleam", 905).
?DOC(" Index of maximum value\n").
-spec argmax(viva_tensor@tensor:tensor()) -> integer().
argmax(T) ->
    viva_tensor@tensor:argmax(T).

-file("src/viva_tensor.gleam", 910).
?DOC(" Index of maximum value, preserving materialization and empty-tensor errors.\n").
-spec try_argmax(viva_tensor@tensor:tensor()) -> {ok, integer()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_argmax(T) ->
    viva_tensor@tensor:try_argmax(T).

-file("src/viva_tensor.gleam", 915).
?DOC(" Index of minimum value\n").
-spec argmin(viva_tensor@tensor:tensor()) -> integer().
argmin(T) ->
    viva_tensor@tensor:argmin(T).

-file("src/viva_tensor.gleam", 920).
?DOC(" Index of minimum value, preserving materialization and empty-tensor errors.\n").
-spec try_argmin(viva_tensor@tensor:tensor()) -> {ok, integer()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_argmin(T) ->
    viva_tensor@tensor:try_argmin(T).

-file("src/viva_tensor.gleam", 925).
?DOC(" Variance\n").
-spec variance(viva_tensor@tensor:tensor()) -> float().
variance(T) ->
    viva_tensor@tensor:variance(T).

-file("src/viva_tensor.gleam", 930).
?DOC(" Variance, preserving materialization and empty-tensor errors.\n").
-spec try_variance(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_variance(T) ->
    viva_tensor@tensor:try_variance(T).

-file("src/viva_tensor.gleam", 935).
?DOC(" Standard deviation\n").
-spec std(viva_tensor@tensor:tensor()) -> float().
std(T) ->
    viva_tensor@tensor:std(T).

-file("src/viva_tensor.gleam", 940).
?DOC(" Standard deviation, preserving materialization and empty-tensor errors.\n").
-spec try_std(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_std(T) ->
    viva_tensor@tensor:try_std(T).

-file("src/viva_tensor.gleam", 947).
?DOC(" Dot product (vectors only)\n").
-spec dot(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        float()} |
    {error, viva_tensor@core@error:tensor_error()}.
dot(A, B) ->
    viva_tensor@tensor:dot(A, B).

-file("src/viva_tensor.gleam", 952).
?DOC(" Matrix-matrix multiplication\n").
-spec matmul(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul(A, B) ->
    viva_tensor@tensor:matmul(A, B).

-file("src/viva_tensor.gleam", 3132).
-spec matmul_native_cpu(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    integer(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_native_cpu(A, B, M, N, K) ->
    gleam@result:'try'(
        viva_tensor@tensor:native_from_list(
            viva_tensor@tensor:to_list(A),
            [M, K]
        ),
        fun(A_native) ->
            gleam@result:'try'(
                viva_tensor@tensor:native_from_list(
                    viva_tensor@tensor:to_list(B),
                    [K, N]
                ),
                fun(B_native) ->
                    viva_tensor@tensor:matmul(A_native, B_native)
                end
            )
        end
    ).

-file("src/viva_tensor.gleam", 3125).
-spec matmul_cuda_fp32(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_cuda_fp32(A, B) ->
    gleam@result:'try'(
        viva_tensor@native@cuda:to_rtx4090_fp32(A),
        fun(A_gpu) ->
            gleam@result:'try'(
                viva_tensor@native@cuda:to_rtx4090_fp32(B),
                fun(B_gpu) ->
                    gleam@result:'try'(
                        viva_tensor@native@cuda:matmul_accelerated(A_gpu, B_gpu),
                        fun(Out) ->
                            viva_tensor@native@cuda:to_cpu_tensor(Out)
                        end
                    )
                end
            )
        end
    ).

-file("src/viva_tensor.gleam", 3118).
-spec matmul_cuda_fp16(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_cuda_fp16(A, B) ->
    gleam@result:'try'(
        viva_tensor@native@cuda:to_rtx4090_fp16(A),
        fun(A_gpu) ->
            gleam@result:'try'(
                viva_tensor@native@cuda:to_rtx4090_fp16(B),
                fun(B_gpu) ->
                    gleam@result:'try'(
                        viva_tensor@native@cuda:matmul_accelerated(A_gpu, B_gpu),
                        fun(Out) ->
                            viva_tensor@native@cuda:to_cpu_tensor(Out)
                        end
                    )
                end
            )
        end
    ).

-file("src/viva_tensor.gleam", 3093).
-spec matmul_with_backend(
    tensor_backend(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    integer(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_with_backend(Backend, A, B, M, N, K) ->
    case Backend of
        backend_cuda_sparse ->
            {error,
                {dimension_error,
                    <<"Sparse Tensor Core dispatch requires an explicit sparse tensor."/utf8>>}};

        backend_cuda_int8 ->
            {error,
                {dimension_error,
                    <<"INT8 Tensor Core dispatch requires explicit quantized tensors."/utf8>>}};

        backend_cuda_fp16 ->
            matmul_cuda_fp16(A, B);

        backend_cuda_fp32 ->
            matmul_cuda_fp32(A, B);

        backend_mkl ->
            matmul_native_cpu(A, B, M, N, K);

        backend_zig_simd ->
            matmul_native_cpu(A, B, M, N, K);

        backend_pure_gleam ->
            viva_tensor@tensor:matmul(A, B)
    end.

-file("src/viva_tensor.gleam", 3075).
-spec run_matmul_backends(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    integer(),
    integer(),
    list(tensor_backend())
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
run_matmul_backends(A, B, M, N, K, Backends) ->
    case Backends of
        [] ->
            viva_tensor@tensor:matmul(A, B);

        [Backend | Rest] ->
            case matmul_with_backend(Backend, A, B, M, N, K) of
                {ok, Result} ->
                    {ok, Result};

                {error, _} ->
                    run_matmul_backends(A, B, M, N, K, Rest)
            end
    end.

-file("src/viva_tensor.gleam", 3057).
-spec backend_is_available(tensor_backend(), list(backend_capability())) -> boolean().
backend_is_available(Backend, Capabilities) ->
    _pipe = Capabilities,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Capability) ->
            {capability,
                erlang:element(2, Capability),
                erlang:element(3, Capability),
                erlang:element(4, Capability),
                erlang:element(5, Capability),
                erlang:element(6, Capability),
                erlang:element(7, Capability)}
        end
    ),
    (fun(Capabilities@1) ->
        viva_tensor@backend@dispatch:is_available(Backend, Capabilities@1)
    end)(_pipe@1).

-file("src/viva_tensor.gleam", 2973).
-spec backend_set() -> viva_tensor@backend@dispatch:backend_set(tensor_backend()).
backend_set() ->
    {backend_set,
        backend_pure_gleam,
        backend_zig_simd,
        backend_mkl,
        backend_cuda_fp32,
        backend_cuda_fp16,
        backend_cuda_int8,
        backend_cuda_sparse}.

-file("src/viva_tensor.gleam", 3023).
-spec build_backend_capabilities(
    boolean(),
    list(viva_tensor@native@tflops:backend())
) -> list(backend_capability()).
build_backend_capabilities(Zig_loaded, Backends) ->
    _pipe = viva_tensor@backend@dispatch:capabilities(
        backend_set(),
        backend_beam_cpu,
        backend_native_cpu,
        backend_cuda,
        backend_float64,
        backend_float32,
        backend_float16,
        backend_int8,
        backend_sparse_float16,
        backend_elementwise,
        backend_broadcast,
        backend_reduction,
        backend_softmax,
        backend_matmul,
        Zig_loaded,
        Backends
    ),
    gleam@list:map(
        _pipe,
        fun(Capability) ->
            {backend_capability,
                erlang:element(2, Capability),
                erlang:element(3, Capability),
                erlang:element(4, Capability),
                erlang:element(5, Capability),
                erlang:element(6, Capability),
                erlang:element(7, Capability)}
        end
    ).

-file("src/viva_tensor.gleam", 2579).
?DOC(" Detect available compute backends\n").
-spec detect_backends() -> list(viva_tensor@native@tflops:backend()).
detect_backends() ->
    viva_tensor@native@tflops:detect_backends().

-file("src/viva_tensor.gleam", 2584).
?DOC(" Inspect native runtime acceleration availability.\n").
-spec capabilities() -> tensor_capabilities().
capabilities() ->
    Nif_loaded = viva_tensor@core@ffi:is_nif_loaded(),
    Zig_loaded = case Nif_loaded of
        true ->
            viva_tensor@core@ffi:zig_is_loaded();

        false ->
            false
    end,
    Backend_info = case Zig_loaded of
        true ->
            viva_tensor@core@ffi:zig_backend_info();

        false ->
            <<"Zig NIF not loaded"/utf8>>
    end,
    Backends = case Nif_loaded of
        true ->
            detect_backends();

        false ->
            [pure_erlang]
    end,
    {tensor_capabilities,
        Nif_loaded,
        Zig_loaded,
        Backend_info,
        Backends,
        build_backend_capabilities(Zig_loaded, Backends)}.

-file("src/viva_tensor.gleam", 3009).
-spec to_tensor_backend_plan(
    viva_tensor@backend@dispatch:plan(tensor_operation(), tensor_backend())
) -> tensor_backend_plan().
to_tensor_backend_plan(Plan) ->
    {tensor_backend_plan,
        erlang:element(2, Plan),
        erlang:element(3, Plan),
        erlang:element(4, Plan),
        gleam@list:map(
            erlang:element(5, Plan),
            fun(Rejection) ->
                {backend_rejection,
                    erlang:element(2, Rejection),
                    erlang:element(3, Rejection)}
            end
        ),
        erlang:element(6, Plan)}.

-file("src/viva_tensor.gleam", 2997).
-spec operation_kind(tensor_operation()) -> viva_tensor@backend@dispatch:operation_kind().
operation_kind(Operation) ->
    case Operation of
        operation_elementwise ->
            elementwise;

        operation_broadcast ->
            broadcast;

        operation_reduction ->
            reduction;

        operation_softmax ->
            softmax;

        {operation_matmul, M, N, K} ->
            {matmul, M, N, K}
    end.

-file("src/viva_tensor.gleam", 2811).
-spec available_backends_from_capabilities(list(backend_capability())) -> list(tensor_backend()).
available_backends_from_capabilities(Capabilities) ->
    _pipe = Capabilities,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Capability) ->
            {capability,
                erlang:element(2, Capability),
                erlang:element(3, Capability),
                erlang:element(4, Capability),
                erlang:element(5, Capability),
                erlang:element(6, Capability),
                erlang:element(7, Capability)}
        end
    ),
    viva_tensor@backend@dispatch:available_backends(_pipe@1).

-file("src/viva_tensor.gleam", 2691).
?DOC(" Plan which backend should handle an operation on this VM.\n").
-spec plan_backend(tensor_operation()) -> tensor_backend_plan().
plan_backend(Operation) ->
    Caps = capabilities(),
    Available = available_backends_from_capabilities(erlang:element(6, Caps)),
    _pipe = viva_tensor@backend@dispatch:plan_backend(
        Operation,
        operation_kind(Operation),
        Available,
        backend_set(),
        erlang:element(2, Caps)
    ),
    to_tensor_backend_plan(_pipe).

-file("src/viva_tensor.gleam", 956).
-spec matmul_planned(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_planned(A, B) ->
    case {viva_tensor@tensor:shape(A), viva_tensor@tensor:shape(B)} of
        {[M, K], [K2, N]} when K =:= K2 ->
            Plan = plan_backend({operation_matmul, M, N, K}),
            Caps = capabilities(),
            Runnable = begin
                _pipe = erlang:element(4, Plan),
                gleam@list:filter(
                    _pipe,
                    fun(Backend) ->
                        backend_is_available(Backend, erlang:element(6, Caps))
                    end
                )
            end,
            run_matmul_backends(A, B, M, N, K, Runnable);

        {_, _} ->
            viva_tensor@tensor:matmul(A, B)
    end.

-file("src/viva_tensor.gleam", 974).
?DOC(" Matrix multiplication with priority: RTX 4090 first, then MKL/native CPU.\n").
-spec matmul_auto(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@native@cuda:accelerated_tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_auto(A, B) ->
    viva_tensor@native@cuda:matmul_auto(A, B).

-file("src/viva_tensor.gleam", 982).
?DOC(" Matrix multiplication between persistent accelerated tensors.\n").
-spec matmul_accelerated(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor()
) -> {ok, viva_tensor@native@cuda:accelerated_tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_accelerated(A, B) ->
    viva_tensor@native@cuda:matmul_accelerated(A, B).

-file("src/viva_tensor.gleam", 990).
?DOC(" Write `out = a @ b` into a persistent accelerated output buffer.\n").
-spec matmul_accelerated_into(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
matmul_accelerated_into(Out, A, B) ->
    viva_tensor@native@cuda:matmul_accelerated_into(Out, A, B).

-file("src/viva_tensor.gleam", 999).
?DOC(" Write `out = relu(a @ b)` using the FP16 Tensor Core fused epilogue.\n").
-spec matmul_relu_accelerated_into(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
matmul_relu_accelerated_into(Out, A, B) ->
    viva_tensor@native@cuda:matmul_relu_accelerated_into(Out, A, B).

-file("src/viva_tensor.gleam", 1008).
?DOC(" Write `out = gelu(a @ b)` using the FP16 Tensor Core fused epilogue.\n").
-spec matmul_gelu_accelerated_into(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
matmul_gelu_accelerated_into(Out, A, B) ->
    viva_tensor@native@cuda:matmul_gelu_accelerated_into(Out, A, B).

-file("src/viva_tensor.gleam", 1017).
?DOC(" Write `out = relu(a @ b + bias)` using the FP16 Tensor Core fused epilogue.\n").
-spec linear_relu_accelerated_into(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
linear_relu_accelerated_into(Out, A, B, Bias) ->
    viva_tensor@native@cuda:linear_relu_accelerated_into(Out, A, B, Bias).

-file("src/viva_tensor.gleam", 1027).
?DOC(" Write `out = gelu(a @ b + bias)` using the FP16 Tensor Core fused epilogue.\n").
-spec linear_gelu_accelerated_into(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
linear_gelu_accelerated_into(Out, A, B, Bias) ->
    viva_tensor@native@cuda:linear_gelu_accelerated_into(Out, A, B, Bias).

-file("src/viva_tensor.gleam", 1037).
?DOC(" Allocate a reusable output buffer for a persisted linear layer.\n").
-spec linear_output(
    viva_tensor@native@cuda:gpu_workspace(),
    viva_tensor@native@cuda:linear_layer(),
    integer()
) -> {ok, viva_tensor@native@cuda:accelerated_tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_output(Workspace, Layer, Batch_size) ->
    viva_tensor@native@cuda:linear_output(Workspace, Layer, Batch_size).

-file("src/viva_tensor.gleam", 1046).
?DOC(" Run `out = relu(input @ layer.weight + layer.bias)`.\n").
-spec linear_relu_forward_into(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:linear_layer()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
linear_relu_forward_into(Out, Input, Layer) ->
    viva_tensor@native@cuda:linear_relu_forward_into(Out, Input, Layer).

-file("src/viva_tensor.gleam", 1055).
?DOC(" Run `out = gelu(input @ layer.weight + layer.bias)`.\n").
-spec linear_gelu_forward_into(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@native@cuda:linear_layer()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
linear_gelu_forward_into(Out, Input, Layer) ->
    viva_tensor@native@cuda:linear_gelu_forward_into(Out, Input, Layer).

-file("src/viva_tensor.gleam", 1064).
?DOC(" Download an accelerated tensor back to a regular CPU tensor.\n").
-spec accelerated_to_tensor(viva_tensor@native@cuda:accelerated_tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
accelerated_to_tensor(T) ->
    viva_tensor@native@cuda:to_cpu_tensor(T).

-file("src/viva_tensor.gleam", 1071).
?DOC(" Inspect which backend was selected by `matmul_auto`.\n").
-spec accelerated_backend(viva_tensor@native@cuda:accelerated_tensor()) -> viva_tensor@native@cuda:acceleration_backend().
accelerated_backend(T) ->
    viva_tensor@native@cuda:backend(T).

-file("src/viva_tensor.gleam", 1076).
?DOC(" Shape of an accelerated tensor without forcing a download.\n").
-spec accelerated_shape(viva_tensor@native@cuda:accelerated_tensor()) -> list(integer()).
accelerated_shape(T) ->
    viva_tensor@native@cuda:accelerated_shape(T).

-file("src/viva_tensor.gleam", 1081).
?DOC(" Wait for queued CUDA work to complete.\n").
-spec accelerated_sync() -> {ok, nil} |
    {error, viva_tensor@core@error:tensor_error()}.
accelerated_sync() ->
    viva_tensor@native@cuda:sync().

-file("src/viva_tensor.gleam", 1086).
?DOC(" Workspace backend.\n").
-spec workspace_backend(viva_tensor@native@cuda:gpu_workspace()) -> viva_tensor@native@cuda:acceleration_backend().
workspace_backend(Workspace) ->
    viva_tensor@native@cuda:workspace_backend(Workspace).

-file("src/viva_tensor.gleam", 1091).
?DOC(" Linear layer backend.\n").
-spec linear_layer_backend(viva_tensor@native@cuda:linear_layer()) -> viva_tensor@native@cuda:acceleration_backend().
linear_layer_backend(Layer) ->
    viva_tensor@native@cuda:linear_layer_backend(Layer).

-file("src/viva_tensor.gleam", 1096).
?DOC(" Linear layer input feature count.\n").
-spec linear_layer_input_features(viva_tensor@native@cuda:linear_layer()) -> integer().
linear_layer_input_features(Layer) ->
    viva_tensor@native@cuda:linear_layer_input_features(Layer).

-file("src/viva_tensor.gleam", 1101).
?DOC(" Linear layer output feature count.\n").
-spec linear_layer_output_features(viva_tensor@native@cuda:linear_layer()) -> integer().
linear_layer_output_features(Layer) ->
    viva_tensor@native@cuda:linear_layer_output_features(Layer).

-file("src/viva_tensor.gleam", 1106).
?DOC(" Write out = a @ b into a preallocated native tensor.\n").
-spec matmul_into(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
matmul_into(Out, A, B) ->
    viva_tensor@tensor:matmul_into(Out, A, B).

-file("src/viva_tensor.gleam", 1115).
?DOC(" Fused linear layer with ReLU: max(0, a @ b + bias).\n").
-spec linear_relu(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_relu(A, B, Bias) ->
    viva_tensor@tensor:linear_relu(A, B, Bias).

-file("src/viva_tensor.gleam", 1124).
?DOC(" Write out = max(0, a @ b + bias) into a preallocated native tensor.\n").
-spec linear_relu_into(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
linear_relu_into(Out, A, B, Bias) ->
    viva_tensor@tensor:linear_relu_into(Out, A, B, Bias).

-file("src/viva_tensor.gleam", 1134).
?DOC(" Matrix-vector multiplication\n").
-spec matmul_vec(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_vec(Mat, Vec) ->
    viva_tensor@tensor:matmul_vec(Mat, Vec).

-file("src/viva_tensor.gleam", 1139).
?DOC(" Matrix transpose\n").
-spec transpose(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
transpose(T) ->
    viva_tensor@tensor:transpose(T).

-file("src/viva_tensor.gleam", 1144).
?DOC(" Outer product\n").
-spec outer(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
outer(A, B) ->
    viva_tensor@tensor:outer(A, B).

-file("src/viva_tensor.gleam", 1149).
?DOC(" Einstein summation. See `viva_tensor/tensor.einsum` for the full spec.\n").
-spec einsum(binary(), list(viva_tensor@tensor:tensor())) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
einsum(Equation, Operands) ->
    viva_tensor@tensor:einsum(Equation, Operands).

-file("src/viva_tensor.gleam", 1161).
?DOC(
    " Solve `A x = b` for a square `A` using Gaussian elimination with partial\n"
    " pivoting. `b` may be 1D or 2D.\n"
).
-spec solve(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
solve(A, B) ->
    viva_tensor@core@linalg:solve(A, B).

-file("src/viva_tensor.gleam", 1166).
?DOC(" Matrix inverse via `solve(a, identity)`. Errors when `a` is singular.\n").
-spec inv(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
inv(A) ->
    viva_tensor@core@linalg:inv(A).

-file("src/viva_tensor.gleam", 1171).
?DOC(" Determinant via LU decomposition. Returns 0.0 for singular matrices.\n").
-spec det(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
det(A) ->
    viva_tensor@core@linalg:det(A).

-file("src/viva_tensor.gleam", 1176).
?DOC(" LU decomposition with partial pivoting. Returns `#(L, U, perm)`.\n").
-spec lu(viva_tensor@tensor:tensor()) -> {ok,
        {viva_tensor@tensor:tensor(),
            viva_tensor@tensor:tensor(),
            list(integer())}} |
    {error, viva_tensor@core@error:tensor_error()}.
lu(A) ->
    viva_tensor@core@linalg:lu(A).

-file("src/viva_tensor.gleam", 1182).
?DOC(
    " Cholesky decomposition for symmetric positive-definite matrices.\n"
    " Returns lower-triangular `L` with `A = L @ L^T`.\n"
).
-spec cholesky(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
cholesky(A) ->
    viva_tensor@core@linalg:cholesky(A).

-file("src/viva_tensor.gleam", 1187).
?DOC(" QR decomposition via classical Gram-Schmidt. Returns `#(Q, R)`.\n").
-spec qr(viva_tensor@tensor:tensor()) -> {ok,
        {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
qr(A) ->
    viva_tensor@core@linalg:qr(A).

-file("src/viva_tensor.gleam", 1192).
?DOC(" SVD stub (not implemented in v1).\n").
-spec svd(viva_tensor@tensor:tensor()) -> {ok,
        {viva_tensor@tensor:tensor(),
            viva_tensor@tensor:tensor(),
            viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
svd(A) ->
    viva_tensor@core@linalg:svd(A).

-file("src/viva_tensor.gleam", 1197).
?DOC(" Eigendecomposition stub (not implemented in v1).\n").
-spec eig(viva_tensor@tensor:tensor()) -> {ok,
        {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
eig(A) ->
    viva_tensor@core@linalg:eig(A).

-file("src/viva_tensor.gleam", 1204).
?DOC(" Reshape (total size must match)\n").
-spec reshape(viva_tensor@tensor:tensor(), list(integer())) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
reshape(T, New_shape) ->
    viva_tensor@tensor:reshape(T, New_shape).

-file("src/viva_tensor.gleam", 1209).
?DOC(" Flatten to 1D\n").
-spec flatten(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
flatten(T) ->
    viva_tensor@tensor:flatten(T).

-file("src/viva_tensor.gleam", 1214).
?DOC(" Flatten to 1D, preserving materialization failures.\n").
-spec try_flatten(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_flatten(T) ->
    viva_tensor@tensor:try_flatten(T).

-file("src/viva_tensor.gleam", 1219).
?DOC(" Remove dimensions of size 1\n").
-spec squeeze(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
squeeze(T) ->
    viva_tensor@tensor:squeeze(T).

-file("src/viva_tensor.gleam", 1224).
?DOC(" Add dimension of size 1\n").
-spec unsqueeze(viva_tensor@tensor:tensor(), integer()) -> viva_tensor@tensor:tensor().
unsqueeze(T, Axis) ->
    viva_tensor@tensor:unsqueeze(T, Axis).

-file("src/viva_tensor.gleam", 1229).
?DOC(" Add dimension of size 1, preserving invalid-axis errors.\n").
-spec try_unsqueeze(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_unsqueeze(T, Axis) ->
    viva_tensor@tensor:try_unsqueeze(T, Axis).

-file("src/viva_tensor.gleam", 1234).
?DOC(" Take flattened elements by explicit indices (legacy: ignores tensor shape).\n").
-spec take_flat(viva_tensor@tensor:tensor(), list(integer())) -> viva_tensor@tensor:tensor().
take_flat(T, Indices) ->
    viva_tensor@tensor:take_flat(T, Indices).

-file("src/viva_tensor.gleam", 1239).
?DOC(" Take flattened elements by explicit indices, preserving index errors.\n").
-spec try_take_flat(viva_tensor@tensor:tensor(), list(integer())) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_take_flat(T, Indices) ->
    viva_tensor@tensor:try_take_flat(T, Indices).

-file("src/viva_tensor.gleam", 1247).
?DOC(" Take flattened elements by explicit indices, preserving index errors.\n").
-spec try_take(viva_tensor@tensor:tensor(), list(integer())) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_take(T, Indices) ->
    viva_tensor@tensor:try_take(T, Indices).

-file("src/viva_tensor.gleam", 1252).
?DOC(" Gather slices along `axis` at each of the given indices (NumPy-style `take`).\n").
-spec take(viva_tensor@tensor:tensor(), list(integer()), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
take(T, Indices, Axis) ->
    viva_tensor@tensor:take(T, Indices, Axis).

-file("src/viva_tensor.gleam", 1261).
?DOC(" Convenience wrapper around `take` for 1D integer-valued index tensors.\n").
-spec gather(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
gather(T, Indices) ->
    viva_tensor@tensor:gather(T, Indices).

-file("src/viva_tensor.gleam", 1266).
?DOC(" Select elements of `t` where the same-shaped `mask` tensor is non-zero.\n").
-spec mask_select(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
mask_select(T, Mask) ->
    viva_tensor@tensor:mask_select(T, Mask).

-file("src/viva_tensor.gleam", 1271).
?DOC(" Return flattened indices for non-zero values, represented as floats (legacy).\n").
-spec nonzero_flat(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
nonzero_flat(T) ->
    viva_tensor@tensor:nonzero_flat(T).

-file("src/viva_tensor.gleam", 1276).
?DOC(" Return flattened indices for non-zero values, represented as floats (legacy).\n").
-spec try_nonzero_flat(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_nonzero_flat(T) ->
    viva_tensor@tensor:try_nonzero_flat(T).

-file("src/viva_tensor.gleam", 1281).
?DOC(" Return flattened indices for non-zero values, preserving materialization failures.\n").
-spec try_nonzero(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_nonzero(T) ->
    viva_tensor@tensor:try_nonzero(T).

-file("src/viva_tensor.gleam", 1286).
?DOC(" Return multi-dimensional indices of non-zero elements of `t` (NumPy `nonzero`).\n").
-spec nonzero(viva_tensor@tensor:tensor()) -> {ok, list(list(integer()))} |
    {error, viva_tensor@core@error:tensor_error()}.
nonzero(T) ->
    viva_tensor@tensor:nonzero(T).

-file("src/viva_tensor.gleam", 1291).
?DOC(" Select flattened values where a broadcasted mask is non-zero.\n").
-spec masked_select(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
masked_select(T, Mask) ->
    viva_tensor@tensor:masked_select(T, Mask).

-file("src/viva_tensor.gleam", 1296).
?DOC(" Select flattened values where a broadcasted mask is non-zero, preserving errors.\n").
-spec try_masked_select(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_masked_select(T, Mask) ->
    viva_tensor@tensor:try_masked_select(T, Mask).

-file("src/viva_tensor.gleam", 1314).
?DOC(" Initialize an embedding table with zero weights.\n").
-spec embedding_init(integer(), integer()) -> viva_tensor@nn@embedding:embedding().
embedding_init(Num_embeddings, Embedding_dim) ->
    viva_tensor@nn@embedding:embedding_init(Num_embeddings, Embedding_dim).

-file("src/viva_tensor.gleam", 1320).
?DOC(
    " Initialize an embedding table with uniform random weights in\n"
    " `[-1/sqrt(embedding_dim), 1/sqrt(embedding_dim)]`.\n"
).
-spec embedding_init_uniform(integer(), integer()) -> viva_tensor@nn@embedding:embedding().
embedding_init_uniform(Num_embeddings, Embedding_dim) ->
    viva_tensor@nn@embedding:embedding_init_uniform(
        Num_embeddings,
        Embedding_dim
    ).

-file("src/viva_tensor.gleam", 1328).
?DOC(" Forward pass: gather rows of `weight` by integer indices.\n").
-spec embedding_forward(
    viva_tensor@nn@embedding:embedding(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
embedding_forward(Layer, Indices) ->
    viva_tensor@nn@embedding:embedding_forward(Layer, Indices).

-file("src/viva_tensor.gleam", 1336).
?DOC(" Sinusoidal positional encoding (\"Attention Is All You Need\").\n").
-spec sinusoidal_encoding(integer(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
sinusoidal_encoding(Max_len, Embedding_dim) ->
    viva_tensor@nn@embedding:sinusoidal_encoding(Max_len, Embedding_dim).

-file("src/viva_tensor.gleam", 1344).
?DOC(" Initialize a learned positional encoding table.\n").
-spec learned_positional_init(integer(), integer()) -> viva_tensor@nn@embedding:learned_positional_encoding().
learned_positional_init(Max_len, Embedding_dim) ->
    viva_tensor@nn@embedding:learned_positional_init(Max_len, Embedding_dim).

-file("src/viva_tensor.gleam", 1352).
?DOC(" Look up positions `0..len-1` from a learned positional encoding.\n").
-spec learned_positional_forward(
    viva_tensor@nn@embedding:learned_positional_encoding(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
learned_positional_forward(Layer, Len) ->
    viva_tensor@nn@embedding:learned_positional_forward(Layer, Len).

-file("src/viva_tensor.gleam", 1360).
?DOC(" Apply Rotary Positional Embedding (RoPE) to a `[seq_len, dim]` tensor.\n").
-spec rope(viva_tensor@tensor:tensor(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
rope(Input, Base) ->
    viva_tensor@nn@embedding:rope(Input, Base).

-file("src/viva_tensor.gleam", 1367).
?DOC(" Shape as list of dimensions\n").
-spec shape(viva_tensor@tensor:tensor()) -> list(integer()).
shape(T) ->
    viva_tensor@tensor:shape(T).

-file("src/viva_tensor.gleam", 1372).
?DOC(" Get total size\n").
-spec size(viva_tensor@tensor:tensor()) -> integer().
size(T) ->
    viva_tensor@tensor:size(T).

-file("src/viva_tensor.gleam", 1377).
?DOC(" Get rank (number of dimensions)\n").
-spec rank(viva_tensor@tensor:tensor()) -> integer().
rank(T) ->
    viva_tensor@tensor:rank(T).

-file("src/viva_tensor.gleam", 1382).
?DOC(" Inspect storage, device, dtype, shape, strides, offset, size, and rank.\n").
-spec layout(viva_tensor@tensor:tensor()) -> viva_tensor@layout:tensor_layout().
layout(T) ->
    viva_tensor@tensor:layout(T).

-file("src/viva_tensor.gleam", 2919).
-spec to_public_device(viva_tensor@layout:tensor_device()) -> tensor_device().
to_public_device(Device) ->
    case Device of
        beam_cpu ->
            beam_cpu;

        native_cpu ->
            native_cpu;

        {cuda_device, Index} ->
            {cuda_device, Index}
    end.

-file("src/viva_tensor.gleam", 1387).
?DOC(" Inspect where a tensor payload lives.\n").
-spec device(viva_tensor@tensor:tensor()) -> tensor_device().
device(T) ->
    Info = layout(T),
    to_public_device(erlang:element(3, Info)).

-file("src/viva_tensor.gleam", 2935).
-spec to_public_dtype(viva_tensor@layout:tensor_dtype()) -> tensor_dtype().
to_public_dtype(Dtype) ->
    case Dtype of
        float64 ->
            float64;

        float32 ->
            float32;

        float16 ->
            float16;

        b_float16 ->
            b_float16;

        float8_e4_m3 ->
            float8_e4_m3;

        int8 ->
            int8;

        int4 ->
            int4;

        sparse_float16 ->
            sparse_float16
    end.

-file("src/viva_tensor.gleam", 1393).
?DOC(" Inspect the tensor element type.\n").
-spec dtype(viva_tensor@tensor:tensor()) -> tensor_dtype().
dtype(T) ->
    Info = layout(T),
    to_public_dtype(erlang:element(4, Info)).

-file("src/viva_tensor.gleam", 1399).
?DOC(" Convert to list\n").
-spec to_list(viva_tensor@tensor:tensor()) -> list(float()).
to_list(T) ->
    viva_tensor@tensor:to_list(T).

-file("src/viva_tensor.gleam", 1404).
?DOC(" Convert to list, preserving native materialization failures.\n").
-spec try_to_list(viva_tensor@tensor:tensor()) -> {ok, list(float())} |
    {error, viva_tensor@core@error:tensor_error()}.
try_to_list(T) ->
    viva_tensor@tensor:try_to_list(T).

-file("src/viva_tensor.gleam", 1425).
?DOC(
    " Default print options. Matches a sensible NumPy/PyTorch baseline:\n"
    " `precision=4, threshold=1000, edgeitems=3, linewidth=80`.\n"
).
-spec default_print_options() -> viva_tensor@core@format:print_options().
default_print_options() ->
    viva_tensor@core@format:default_print_options().

-file("src/viva_tensor.gleam", 1431).
?DOC(
    " Render a tensor as a pretty multi-line string with column alignment\n"
    " and elision for large tensors.\n"
).
-spec to_string(viva_tensor@tensor:tensor()) -> binary().
to_string(T) ->
    viva_tensor@core@format:to_string(T).

-file("src/viva_tensor.gleam", 1436).
?DOC(" Render a tensor with caller-supplied print options.\n").
-spec to_string_with(
    viva_tensor@tensor:tensor(),
    viva_tensor@core@format:print_options()
) -> binary().
to_string_with(T, Opts) ->
    viva_tensor@core@format:to_string_with(T, Opts).

-file("src/viva_tensor.gleam", 1442).
?DOC(
    " Alias for `to_string` — matches the NumPy/PyTorch `inspect` /\n"
    " `__repr__` convention.\n"
).
-spec inspect(viva_tensor@tensor:tensor()) -> binary().
inspect(T) ->
    viva_tensor@core@format:inspect(T).

-file("src/viva_tensor.gleam", 1449).
?DOC(
    " Render an accelerated tensor (CudaFp16/CudaFp32/Cpu) as a pretty\n"
    " string. Large CUDA tensors above the threshold render as\n"
    " header-only to avoid surprise H2D copies.\n"
).
-spec accelerated_to_string(viva_tensor@native@cuda:accelerated_tensor()) -> binary().
accelerated_to_string(T) ->
    viva_tensor@core@format:accelerated_to_string(T).

-file("src/viva_tensor.gleam", 1454).
?DOC(" Render an accelerated tensor with caller-supplied print options.\n").
-spec accelerated_to_string_with(
    viva_tensor@native@cuda:accelerated_tensor(),
    viva_tensor@core@format:print_options()
) -> binary().
accelerated_to_string_with(T, Opts) ->
    viva_tensor@core@format:accelerated_to_string_with(T, Opts).

-file("src/viva_tensor.gleam", 1476).
?DOC(
    " Read a SafeTensors file into a `Dict(String, Tensor)`.\n"
    "\n"
    " Supports `F32` and `F64` payloads. See `viva_tensor/io/safetensors.read`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import gleam/dict\n"
    " import viva_tensor as t\n"
    "\n"
    " let assert Ok(weights) = t.safetensors_read(\"./model.safetensors\")\n"
    " let _ = dict.get(weights, \"encoder.weight\")\n"
    " ```\n"
).
-spec safetensors_read(binary()) -> {ok,
        gleam@dict:dict(binary(), viva_tensor@tensor:tensor())} |
    {error, viva_tensor@core@error:tensor_error()}.
safetensors_read(Path) ->
    viva_tensor@io@safetensors:read(Path).

-file("src/viva_tensor.gleam", 1493).
?DOC(
    " Write a `Dict(String, Tensor)` to disk in SafeTensors format (F64 payload).\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import gleam/dict\n"
    " import viva_tensor as t\n"
    "\n"
    " let weights = dict.from_list([#(\"w\", t.ones([2, 2]))])\n"
    " let assert Ok(Nil) = t.safetensors_write(\"./out.safetensors\", weights)\n"
    " ```\n"
).
-spec safetensors_write(
    binary(),
    gleam@dict:dict(binary(), viva_tensor@tensor:tensor())
) -> {ok, nil} | {error, viva_tensor@core@error:tensor_error()}.
safetensors_write(Path, Tensors) ->
    viva_tensor@io@safetensors:write(Path, Tensors).

-file("src/viva_tensor.gleam", 1523).
?DOC(
    " Parse a JSON-encoded ONNX graph.\n"
    "\n"
    " Supported op set (v1): `Add`, `Sub`, `Mul`, `MatMul`, `Gemm`, `Relu`,\n"
    " `Sigmoid`, `Tanh`, `Gelu`, `Softmax`, `Transpose`, `Reshape`, `Constant`,\n"
    " `LayerNormalization`. See `viva_tensor/io/onnx.parse_graph`.\n"
).
-spec onnx_parse_graph(binary()) -> {ok, viva_tensor@io@onnx:onnx_graph()} |
    {error, viva_tensor@io@onnx:onnx_error()}.
onnx_parse_graph(Json_str) ->
    viva_tensor@io@onnx:parse_graph(Json_str).

-file("src/viva_tensor.gleam", 1531).
?DOC(
    " Execute a parsed ONNX graph against a dict of named input tensors.\n"
    "\n"
    " Returns the full execution table — pick the named graph outputs from it.\n"
    " See `viva_tensor/io/onnx.run_graph` for the v1 supported op set.\n"
).
-spec onnx_run_graph(
    viva_tensor@io@onnx:onnx_graph(),
    gleam@dict:dict(binary(), viva_tensor@tensor:tensor())
) -> {ok, gleam@dict:dict(binary(), viva_tensor@tensor:tensor())} |
    {error, viva_tensor@io@onnx:onnx_error()}.
onnx_run_graph(Graph, Feeds) ->
    viva_tensor@io@onnx:run_graph(Graph, Feeds).

-file("src/viva_tensor.gleam", 1539).
?DOC(" Return the list of ONNX op_types supported by `onnx_run_graph` in v1.\n").
-spec onnx_supported_ops() -> list(binary()).
onnx_supported_ops() ->
    viva_tensor@io@onnx:supported_ops().

-file("src/viva_tensor.gleam", 1546).
?DOC(" L2 norm (Euclidean length)\n").
-spec norm(viva_tensor@tensor:tensor()) -> float().
norm(T) ->
    viva_tensor@tensor:norm(T).

-file("src/viva_tensor.gleam", 1551).
?DOC(" L2 norm, preserving materialization failures.\n").
-spec try_norm(viva_tensor@tensor:tensor()) -> {ok, float()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_norm(T) ->
    viva_tensor@tensor:try_norm(T).

-file("src/viva_tensor.gleam", 1556).
?DOC(" Normalize to unit length\n").
-spec normalize(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
normalize(T) ->
    viva_tensor@tensor:normalize(T).

-file("src/viva_tensor.gleam", 1561).
?DOC(" Normalize to unit length, preserving materialization failures.\n").
-spec try_normalize(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_normalize(T) ->
    viva_tensor@tensor:try_normalize(T).

-file("src/viva_tensor.gleam", 1566).
?DOC(" Compare two scalars with relative and absolute tolerances.\n").
-spec is_close(float(), float(), float(), float()) -> boolean().
is_close(A, B, Rtol, Atol) ->
    viva_tensor@tensor:is_close(A, B, Rtol, Atol).

-file("src/viva_tensor.gleam", 1571).
?DOC(" Compare two tensors element-wise and return whether all pairs are close.\n").
-spec all_close(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    float(),
    float()
) -> {ok, boolean()} | {error, viva_tensor@core@error:tensor_error()}.
all_close(A, B, Rtol, Atol) ->
    viva_tensor@tensor:all_close(A, B, Rtol, Atol).

-file("src/viva_tensor.gleam", 1581).
?DOC(" Absolute value for every element.\n").
-spec abs(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
abs(T) ->
    viva_tensor@tensor:abs(T).

-file("src/viva_tensor.gleam", 1586).
?DOC(" Absolute value for every element, preserving materialization failures.\n").
-spec try_abs(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_abs(T) ->
    viva_tensor@tensor:try_abs(T).

-file("src/viva_tensor.gleam", 1591).
?DOC(" Square every element.\n").
-spec square(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
square(T) ->
    viva_tensor@tensor:square(T).

-file("src/viva_tensor.gleam", 1596).
?DOC(" Square every element, preserving materialization failures.\n").
-spec try_square(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_square(T) ->
    viva_tensor@tensor:try_square(T).

-file("src/viva_tensor.gleam", 1601).
?DOC(" Square root every element.\n").
-spec sqrt(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
sqrt(T) ->
    viva_tensor@tensor:sqrt(T).

-file("src/viva_tensor.gleam", 1606).
?DOC(" Square root every element, rejecting negative values.\n").
-spec try_sqrt(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_sqrt(T) ->
    viva_tensor@tensor:try_sqrt(T).

-file("src/viva_tensor.gleam", 1611).
?DOC(" Exponential for every element.\n").
-spec exp(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
exp(T) ->
    viva_tensor@tensor:exp(T).

-file("src/viva_tensor.gleam", 1616).
?DOC(" Exponential for every element, preserving materialization failures.\n").
-spec try_exp(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_exp(T) ->
    viva_tensor@tensor:try_exp(T).

-file("src/viva_tensor.gleam", 1621).
?DOC(" Natural logarithm for every element.\n").
-spec log(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
log(T) ->
    viva_tensor@tensor:log(T).

-file("src/viva_tensor.gleam", 1626).
?DOC(" Natural logarithm for every element, rejecting non-positive values.\n").
-spec try_log(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_log(T) ->
    viva_tensor@tensor:try_log(T).

-file("src/viva_tensor.gleam", 1631).
?DOC(" Floor every element.\n").
-spec floor(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
floor(T) ->
    viva_tensor@tensor:floor(T).

-file("src/viva_tensor.gleam", 1636).
?DOC(" Floor every element, preserving materialization failures.\n").
-spec try_floor(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_floor(T) ->
    viva_tensor@tensor:try_floor(T).

-file("src/viva_tensor.gleam", 1641).
?DOC(" Ceiling every element.\n").
-spec ceil(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
ceil(T) ->
    viva_tensor@tensor:ceil(T).

-file("src/viva_tensor.gleam", 1646).
?DOC(" Ceiling every element, preserving materialization failures.\n").
-spec try_ceil(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_ceil(T) ->
    viva_tensor@tensor:try_ceil(T).

-file("src/viva_tensor.gleam", 1651).
?DOC(" Round every element to the nearest integer value.\n").
-spec round(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
round(T) ->
    viva_tensor@tensor:round(T).

-file("src/viva_tensor.gleam", 1656).
?DOC(" Round every element to the nearest integer value, preserving failures.\n").
-spec try_round(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_round(T) ->
    viva_tensor@tensor:try_round(T).

-file("src/viva_tensor.gleam", 1661).
?DOC(" Return -1, 0, or 1 for each element.\n").
-spec sign(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
sign(T) ->
    viva_tensor@tensor:sign(T).

-file("src/viva_tensor.gleam", 1666).
?DOC(" Return -1, 0, or 1 for each element, preserving failures.\n").
-spec try_sign(viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_sign(T) ->
    viva_tensor@tensor:try_sign(T).

-file("src/viva_tensor.gleam", 1671).
?DOC(" Reciprocal for every element.\n").
-spec reciprocal(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
reciprocal(T) ->
    viva_tensor@tensor:reciprocal(T).

-file("src/viva_tensor.gleam", 1676).
?DOC(" Reciprocal for every element, rejecting zeros.\n").
-spec try_reciprocal(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_reciprocal(T) ->
    viva_tensor@tensor:try_reciprocal(T).

-file("src/viva_tensor.gleam", 1681).
?DOC(" Euclidean distance between two same-shaped tensors, flattened as vectors.\n").
-spec euclidean_distance(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> float().
euclidean_distance(A, B) ->
    viva_tensor@tensor:euclidean_distance(A, B).

-file("src/viva_tensor.gleam", 1686).
?DOC(" Euclidean distance between two same-shaped tensors, preserving errors.\n").
-spec try_euclidean_distance(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
try_euclidean_distance(A, B) ->
    viva_tensor@tensor:try_euclidean_distance(A, B).

-file("src/viva_tensor.gleam", 1694).
?DOC(" Manhattan distance between two same-shaped tensors, flattened as vectors.\n").
-spec manhattan_distance(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> float().
manhattan_distance(A, B) ->
    viva_tensor@tensor:manhattan_distance(A, B).

-file("src/viva_tensor.gleam", 1699).
?DOC(" Manhattan distance between two same-shaped tensors, preserving errors.\n").
-spec try_manhattan_distance(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
try_manhattan_distance(A, B) ->
    viva_tensor@tensor:try_manhattan_distance(A, B).

-file("src/viva_tensor.gleam", 1707).
?DOC(" Cosine similarity between two same-shaped tensors, flattened as vectors.\n").
-spec cosine_similarity(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> float().
cosine_similarity(A, B) ->
    viva_tensor@tensor:cosine_similarity(A, B).

-file("src/viva_tensor.gleam", 1712).
?DOC(" Cosine similarity between two same-shaped tensors, preserving errors.\n").
-spec try_cosine_similarity(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
try_cosine_similarity(A, B) ->
    viva_tensor@tensor:try_cosine_similarity(A, B).

-file("src/viva_tensor.gleam", 1720).
?DOC(" Dot similarity between two same-shaped tensors, flattened as vectors.\n").
-spec dot_similarity(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> float().
dot_similarity(A, B) ->
    viva_tensor@tensor:dot_similarity(A, B).

-file("src/viva_tensor.gleam", 1725).
?DOC(" Dot similarity between two same-shaped tensors, preserving errors.\n").
-spec try_dot_similarity(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
try_dot_similarity(A, B) ->
    viva_tensor@tensor:try_dot_similarity(A, B).

-file("src/viva_tensor.gleam", 1730).
?DOC(" Z-score standardization over all elements, preserving shape.\n").
-spec zscore(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
zscore(T) ->
    viva_tensor@tensor:zscore(T).

-file("src/viva_tensor.gleam", 1735).
?DOC(" Z-score standardization over all elements, preserving errors.\n").
-spec try_zscore(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_zscore(T) ->
    viva_tensor@tensor:try_zscore(T).

-file("src/viva_tensor.gleam", 1740).
?DOC(" Alias for `zscore`.\n").
-spec standardize(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
standardize(T) ->
    viva_tensor@tensor:standardize(T).

-file("src/viva_tensor.gleam", 1745).
?DOC(" Alias for `try_zscore`.\n").
-spec try_standardize(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_standardize(T) ->
    viva_tensor@tensor:try_standardize(T).

-file("src/viva_tensor.gleam", 1750).
?DOC(" Scale all values into a target interval.\n").
-spec minmax_scale(viva_tensor@tensor:tensor(), float(), float()) -> viva_tensor@tensor:tensor().
minmax_scale(T, Feature_min, Feature_max) ->
    viva_tensor@tensor:minmax_scale(T, Feature_min, Feature_max).

-file("src/viva_tensor.gleam", 1759).
?DOC(" Scale all values into a target interval, preserving errors.\n").
-spec try_minmax_scale(viva_tensor@tensor:tensor(), float(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_minmax_scale(T, Feature_min, Feature_max) ->
    viva_tensor@tensor:try_minmax_scale(T, Feature_min, Feature_max).

-file("src/viva_tensor.gleam", 1768).
?DOC(" Clip tensor L2 norm to at most `max_norm`.\n").
-spec clip_by_norm(viva_tensor@tensor:tensor(), float()) -> viva_tensor@tensor:tensor().
clip_by_norm(T, Max_norm) ->
    viva_tensor@tensor:clip_by_norm(T, Max_norm).

-file("src/viva_tensor.gleam", 1773).
?DOC(" Clip tensor L2 norm to at most `max_norm`, preserving errors.\n").
-spec try_clip_by_norm(viva_tensor@tensor:tensor(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_clip_by_norm(T, Max_norm) ->
    viva_tensor@tensor:try_clip_by_norm(T, Max_norm).

-file("src/viva_tensor.gleam", 1781).
?DOC(" Add a scalar to every element.\n").
-spec add_scalar(viva_tensor@tensor:tensor(), float()) -> viva_tensor@tensor:tensor().
add_scalar(T, Scalar) ->
    viva_tensor@tensor:add_scalar(T, Scalar).

-file("src/viva_tensor.gleam", 1786).
?DOC(" Add a scalar to every element, preserving materialization failures.\n").
-spec try_add_scalar(viva_tensor@tensor:tensor(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_add_scalar(T, Scalar) ->
    viva_tensor@tensor:try_add_scalar(T, Scalar).

-file("src/viva_tensor.gleam", 1791).
?DOC(" Negate every element.\n").
-spec negate(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
negate(T) ->
    viva_tensor@tensor:negate(T).

-file("src/viva_tensor.gleam", 1796).
?DOC(" Negate every element, preserving materialization failures.\n").
-spec try_negate(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_negate(T) ->
    viva_tensor@tensor:try_negate(T).

-file("src/viva_tensor.gleam", 1801).
?DOC(" Clamp values\n").
-spec clamp(viva_tensor@tensor:tensor(), float(), float()) -> viva_tensor@tensor:tensor().
clamp(T, Min_val, Max_val) ->
    viva_tensor@tensor:clamp(T, Min_val, Max_val).

-file("src/viva_tensor.gleam", 1806).
?DOC(" Clamp values, preserving materialization failures.\n").
-spec try_clamp(viva_tensor@tensor:tensor(), float(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_clamp(T, Min_val, Max_val) ->
    viva_tensor@tensor:try_clamp(T, Min_val, Max_val).

-file("src/viva_tensor.gleam", 1815).
?DOC(" Alias for `clamp`.\n").
-spec clip(viva_tensor@tensor:tensor(), float(), float()) -> viva_tensor@tensor:tensor().
clip(T, Min_val, Max_val) ->
    viva_tensor@tensor:clip(T, Min_val, Max_val).

-file("src/viva_tensor.gleam", 1820).
?DOC(" Alias for `try_clamp`.\n").
-spec try_clip(viva_tensor@tensor:tensor(), float(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_clip(T, Min_val, Max_val) ->
    viva_tensor@tensor:try_clip(T, Min_val, Max_val).

-file("src/viva_tensor.gleam", 1831).
?DOC(" Can these shapes broadcast together?\n").
-spec can_broadcast(list(integer()), list(integer())) -> boolean().
can_broadcast(A, B) ->
    viva_tensor@tensor:can_broadcast(A, B).

-file("src/viva_tensor.gleam", 1836).
?DOC(" Compute the common shape for two broadcastable shapes.\n").
-spec broadcast_shape(list(integer()), list(integer())) -> {ok, list(integer())} |
    {error, viva_tensor@core@error:tensor_error()}.
broadcast_shape(A, B) ->
    viva_tensor@tensor:broadcast_shape(A, B).

-file("src/viva_tensor.gleam", 1844).
?DOC(" Compute the common shape for any number of broadcastable shapes.\n").
-spec broadcast_shapes(list(list(integer()))) -> {ok, list(integer())} |
    {error, viva_tensor@core@error:tensor_error()}.
broadcast_shapes(Shapes) ->
    viva_tensor@tensor:broadcast_shapes(Shapes).

-file("src/viva_tensor.gleam", 1851).
?DOC(" Broadcast tensor to a target shape.\n").
-spec broadcast_to(viva_tensor@tensor:tensor(), list(integer())) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
broadcast_to(T, Target_shape) ->
    viva_tensor@tensor:broadcast_to(T, Target_shape).

-file("src/viva_tensor.gleam", 1859).
?DOC(" Broadcast two tensors to their common shape.\n").
-spec broadcast_pair(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
broadcast_pair(A, B) ->
    viva_tensor@tensor:broadcast_pair(A, B).

-file("src/viva_tensor.gleam", 1867).
?DOC(" Add with broadcasting\n").
-spec add_broadcast(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
add_broadcast(A, B) ->
    viva_tensor@tensor:add_broadcast(A, B).

-file("src/viva_tensor.gleam", 1872).
?DOC(" Subtract with broadcasting\n").
-spec sub_broadcast(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
sub_broadcast(A, B) ->
    viva_tensor@tensor:sub_broadcast(A, B).

-file("src/viva_tensor.gleam", 1877).
?DOC(" Multiply with broadcasting\n").
-spec mul_broadcast(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
mul_broadcast(A, B) ->
    viva_tensor@tensor:mul_broadcast(A, B).

-file("src/viva_tensor.gleam", 1882).
?DOC(" Divide with broadcasting\n").
-spec div_broadcast(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
div_broadcast(A, B) ->
    viva_tensor@tensor:div_broadcast(A, B).

-file("src/viva_tensor.gleam", 1887).
?DOC(" Element-wise maximum with NumPy-style broadcasting.\n").
-spec maximum(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
maximum(A, B) ->
    viva_tensor@tensor:maximum(A, B).

-file("src/viva_tensor.gleam", 1892).
?DOC(" Alias for `maximum`.\n").
-spec try_maximum(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_maximum(A, B) ->
    viva_tensor@tensor:try_maximum(A, B).

-file("src/viva_tensor.gleam", 1897).
?DOC(" Element-wise minimum with NumPy-style broadcasting.\n").
-spec minimum(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
minimum(A, B) ->
    viva_tensor@tensor:minimum(A, B).

-file("src/viva_tensor.gleam", 1902).
?DOC(" Alias for `minimum`.\n").
-spec try_minimum(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_minimum(A, B) ->
    viva_tensor@tensor:try_minimum(A, B).

-file("src/viva_tensor.gleam", 1907).
?DOC(" Element-wise equality mask with NumPy-style broadcasting.\n").
-spec equal(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
equal(A, B) ->
    viva_tensor@tensor:equal(A, B).

-file("src/viva_tensor.gleam", 1912).
?DOC(" Alias for `equal`.\n").
-spec try_equal(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_equal(A, B) ->
    viva_tensor@tensor:try_equal(A, B).

-file("src/viva_tensor.gleam", 1917).
?DOC(" Element-wise inequality mask with NumPy-style broadcasting.\n").
-spec not_equal(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
not_equal(A, B) ->
    viva_tensor@tensor:not_equal(A, B).

-file("src/viva_tensor.gleam", 1922).
?DOC(" Alias for `not_equal`.\n").
-spec try_not_equal(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_not_equal(A, B) ->
    viva_tensor@tensor:try_not_equal(A, B).

-file("src/viva_tensor.gleam", 1927).
?DOC(" Element-wise greater-than mask with NumPy-style broadcasting.\n").
-spec greater(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
greater(A, B) ->
    viva_tensor@tensor:greater(A, B).

-file("src/viva_tensor.gleam", 1932).
?DOC(" Alias for `greater`.\n").
-spec try_greater(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_greater(A, B) ->
    viva_tensor@tensor:try_greater(A, B).

-file("src/viva_tensor.gleam", 1937).
?DOC(" Element-wise greater-than-or-equal mask with NumPy-style broadcasting.\n").
-spec greater_equal(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
greater_equal(A, B) ->
    viva_tensor@tensor:greater_equal(A, B).

-file("src/viva_tensor.gleam", 1942).
?DOC(" Alias for `greater_equal`.\n").
-spec try_greater_equal(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_greater_equal(A, B) ->
    viva_tensor@tensor:try_greater_equal(A, B).

-file("src/viva_tensor.gleam", 1947).
?DOC(" Element-wise less-than mask with NumPy-style broadcasting.\n").
-spec less(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
less(A, B) ->
    viva_tensor@tensor:less(A, B).

-file("src/viva_tensor.gleam", 1952).
?DOC(" Alias for `less`.\n").
-spec try_less(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_less(A, B) ->
    viva_tensor@tensor:try_less(A, B).

-file("src/viva_tensor.gleam", 1957).
?DOC(" Element-wise less-than-or-equal mask with NumPy-style broadcasting.\n").
-spec less_equal(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
less_equal(A, B) ->
    viva_tensor@tensor:less_equal(A, B).

-file("src/viva_tensor.gleam", 1962).
?DOC(" Alias for `less_equal`.\n").
-spec try_less_equal(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_less_equal(A, B) ->
    viva_tensor@tensor:try_less_equal(A, B).

-file("src/viva_tensor.gleam", 1967).
?DOC(" Select values from two tensors using a non-zero condition mask.\n").
-spec where(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
where(Condition, When_true, When_false) ->
    viva_tensor@tensor:where(Condition, When_true, When_false).

-file("src/viva_tensor.gleam", 1976).
?DOC(" Alias for `where`.\n").
-spec try_where(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_where(Condition, When_true, When_false) ->
    viva_tensor@tensor:try_where(Condition, When_true, When_false).

-file("src/viva_tensor.gleam", 1985).
?DOC(" Logical NOT over a numeric mask.\n").
-spec logical_not(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
logical_not(T) ->
    viva_tensor@tensor:logical_not(T).

-file("src/viva_tensor.gleam", 1990).
?DOC(" Logical NOT over a numeric mask, preserving materialization failures.\n").
-spec try_logical_not(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_logical_not(T) ->
    viva_tensor@tensor:try_logical_not(T).

-file("src/viva_tensor.gleam", 1995).
?DOC(" Logical AND over numeric masks with broadcasting.\n").
-spec logical_and(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
logical_and(A, B) ->
    viva_tensor@tensor:logical_and(A, B).

-file("src/viva_tensor.gleam", 2000).
?DOC(" Alias for `logical_and`.\n").
-spec try_logical_and(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_logical_and(A, B) ->
    viva_tensor@tensor:try_logical_and(A, B).

-file("src/viva_tensor.gleam", 2005).
?DOC(" Logical OR over numeric masks with broadcasting.\n").
-spec logical_or(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
logical_or(A, B) ->
    viva_tensor@tensor:logical_or(A, B).

-file("src/viva_tensor.gleam", 2010).
?DOC(" Alias for `logical_or`.\n").
-spec try_logical_or(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_logical_or(A, B) ->
    viva_tensor@tensor:try_logical_or(A, B).

-file("src/viva_tensor.gleam", 2015).
?DOC(" Logical XOR over numeric masks with broadcasting.\n").
-spec logical_xor(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
logical_xor(A, B) ->
    viva_tensor@tensor:logical_xor(A, B).

-file("src/viva_tensor.gleam", 2020).
?DOC(" Alias for `logical_xor`.\n").
-spec try_logical_xor(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_logical_xor(A, B) ->
    viva_tensor@tensor:try_logical_xor(A, B).

-file("src/viva_tensor.gleam", 2025).
?DOC(" Does the mask contain any non-zero value?\n").
-spec any(viva_tensor@tensor:tensor()) -> boolean().
any(T) ->
    viva_tensor@tensor:any(T).

-file("src/viva_tensor.gleam", 2030).
?DOC(" Does the mask contain any non-zero value, preserving materialization failures.\n").
-spec try_any(viva_tensor@tensor:tensor()) -> {ok, boolean()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_any(T) ->
    viva_tensor@tensor:try_any(T).

-file("src/viva_tensor.gleam", 2035).
?DOC(" Are all mask values non-zero?\n").
-spec all(viva_tensor@tensor:tensor()) -> boolean().
all(T) ->
    viva_tensor@tensor:all(T).

-file("src/viva_tensor.gleam", 2040).
?DOC(" Are all mask values non-zero, preserving materialization failures.\n").
-spec try_all(viva_tensor@tensor:tensor()) -> {ok, boolean()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_all(T) ->
    viva_tensor@tensor:try_all(T).

-file("src/viva_tensor.gleam", 2045).
?DOC(" Count non-zero values in a tensor.\n").
-spec count_nonzero(viva_tensor@tensor:tensor()) -> integer().
count_nonzero(T) ->
    viva_tensor@tensor:count_nonzero(T).

-file("src/viva_tensor.gleam", 2050).
?DOC(" Count non-zero values in a tensor, preserving materialization failures.\n").
-spec try_count_nonzero(viva_tensor@tensor:tensor()) -> {ok, integer()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_count_nonzero(T) ->
    viva_tensor@tensor:try_count_nonzero(T).

-file("src/viva_tensor.gleam", 2055).
?DOC(" Does each axis slice contain any non-zero value?\n").
-spec any_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
any_axis(T, Axis) ->
    viva_tensor@tensor:any_axis(T, Axis).

-file("src/viva_tensor.gleam", 2060).
?DOC(" Does each axis slice contain any non-zero value?\n").
-spec try_any_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_any_axis(T, Axis) ->
    viva_tensor@tensor:try_any_axis(T, Axis).

-file("src/viva_tensor.gleam", 2065).
?DOC(" Does each axis slice contain any non-zero value, preserving the reduced dimension.\n").
-spec any_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
any_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:any_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 2070).
?DOC(" Does each axis slice contain any non-zero value, preserving the reduced dimension.\n").
-spec try_any_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_any_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:try_any_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 2078).
?DOC(" Are all values in each axis slice non-zero?\n").
-spec all_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
all_axis(T, Axis) ->
    viva_tensor@tensor:all_axis(T, Axis).

-file("src/viva_tensor.gleam", 2083).
?DOC(" Are all values in each axis slice non-zero?\n").
-spec try_all_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_all_axis(T, Axis) ->
    viva_tensor@tensor:try_all_axis(T, Axis).

-file("src/viva_tensor.gleam", 2088).
?DOC(" Are all values in each axis slice non-zero, preserving the reduced dimension.\n").
-spec all_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
all_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:all_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 2093).
?DOC(" Are all values in each axis slice non-zero, preserving the reduced dimension.\n").
-spec try_all_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_all_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:try_all_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 2101).
?DOC(" Count non-zero values along one axis.\n").
-spec count_nonzero_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
count_nonzero_axis(T, Axis) ->
    viva_tensor@tensor:count_nonzero_axis(T, Axis).

-file("src/viva_tensor.gleam", 2106).
?DOC(" Count non-zero values along one axis.\n").
-spec try_count_nonzero_axis(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_count_nonzero_axis(T, Axis) ->
    viva_tensor@tensor:try_count_nonzero_axis(T, Axis).

-file("src/viva_tensor.gleam", 2114).
?DOC(" Count non-zero values along one axis, preserving the reduced dimension.\n").
-spec count_nonzero_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
count_nonzero_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:count_nonzero_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 2122).
?DOC(" Count non-zero values along one axis, preserving the reduced dimension.\n").
-spec try_count_nonzero_axis_keepdims(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_count_nonzero_axis_keepdims(T, Axis) ->
    viva_tensor@tensor:try_count_nonzero_axis_keepdims(T, Axis).

-file("src/viva_tensor.gleam", 2132).
?DOC(" Convert to strided representation for O(1) element access\n").
-spec to_strided(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
to_strided(T) ->
    viva_tensor@tensor:to_strided(T).

-file("src/viva_tensor.gleam", 2137).
?DOC(" Convert to strided representation, preserving materialization failures.\n").
-spec try_to_strided(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_to_strided(T) ->
    viva_tensor@tensor:try_to_strided(T).

-file("src/viva_tensor.gleam", 2142).
?DOC(" Convert to contiguous tensor\n").
-spec to_contiguous(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
to_contiguous(T) ->
    viva_tensor@tensor:to_contiguous(T).

-file("src/viva_tensor.gleam", 2147).
?DOC(" Convert to contiguous tensor, preserving materialization failures.\n").
-spec try_to_contiguous(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_to_contiguous(T) ->
    viva_tensor@tensor:try_to_contiguous(T).

-file("src/viva_tensor.gleam", 2152).
?DOC(" Zero-copy transpose\n").
-spec transpose_strided(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
transpose_strided(T) ->
    viva_tensor@tensor:transpose_strided(T).

-file("src/viva_tensor.gleam", 2157).
?DOC(" Check if contiguous\n").
-spec is_contiguous(viva_tensor@tensor:tensor()) -> boolean().
is_contiguous(T) ->
    viva_tensor@tensor:is_contiguous(T).

-file("src/viva_tensor.gleam", 2164).
?DOC(" Initialize a `LayerNorm` with default `eps = 1.0e-5`.\n").
-spec layer_norm_init(integer()) -> viva_tensor@nn@norm:layer_norm().
layer_norm_init(Num_features) ->
    viva_tensor@nn@norm:layer_norm_init(Num_features).

-file("src/viva_tensor.gleam", 2169).
?DOC(" Initialize a `LayerNorm` with custom `eps`.\n").
-spec layer_norm_init_with_eps(integer(), float()) -> viva_tensor@nn@norm:layer_norm().
layer_norm_init_with_eps(Num_features, Eps) ->
    viva_tensor@nn@norm:layer_norm_init_with_eps(Num_features, Eps).

-file("src/viva_tensor.gleam", 2174).
?DOC(" Forward pass for `LayerNorm` — normalizes along the last dimension.\n").
-spec layer_norm_forward(
    viva_tensor@nn@norm:layer_norm(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
layer_norm_forward(Layer, Input) ->
    viva_tensor@nn@norm:layer_norm_forward(Layer, Input).

-file("src/viva_tensor.gleam", 2182).
?DOC(" Initialize an `RmsNorm` with default `eps = 1.0e-6`.\n").
-spec rms_norm_init(integer()) -> viva_tensor@nn@norm:rms_norm().
rms_norm_init(Num_features) ->
    viva_tensor@nn@norm:rms_norm_init(Num_features).

-file("src/viva_tensor.gleam", 2187).
?DOC(" Initialize an `RmsNorm` with custom `eps`.\n").
-spec rms_norm_init_with_eps(integer(), float()) -> viva_tensor@nn@norm:rms_norm().
rms_norm_init_with_eps(Num_features, Eps) ->
    viva_tensor@nn@norm:rms_norm_init_with_eps(Num_features, Eps).

-file("src/viva_tensor.gleam", 2192).
?DOC(" Forward pass for `RmsNorm` — RMS normalize along the last dimension.\n").
-spec rms_norm_forward(
    viva_tensor@nn@norm:rms_norm(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
rms_norm_forward(Layer, Input) ->
    viva_tensor@nn@norm:rms_norm_forward(Layer, Input).

-file("src/viva_tensor.gleam", 2200).
?DOC(" Initialize a `BatchNorm1d` with default `momentum = 0.1`, `eps = 1.0e-5`.\n").
-spec batch_norm_1d_init(integer()) -> viva_tensor@nn@norm:batch_norm1d().
batch_norm_1d_init(Num_features) ->
    viva_tensor@nn@norm:batch_norm_1d_init(Num_features).

-file("src/viva_tensor.gleam", 2209).
?DOC(
    " Forward pass for `BatchNorm1d`.\n"
    "\n"
    " In training mode, updates running stats via EMA and returns the new layer\n"
    " alongside the normalized output. In eval mode, uses running stats and\n"
    " returns the layer unchanged.\n"
).
-spec batch_norm_1d_forward(
    viva_tensor@nn@norm:batch_norm1d(),
    viva_tensor@tensor:tensor(),
    boolean()
) -> {ok, {viva_tensor@nn@norm:batch_norm1d(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
batch_norm_1d_forward(Layer, Input, Training) ->
    viva_tensor@nn@norm:batch_norm_1d_forward(Layer, Input, Training).

-file("src/viva_tensor.gleam", 2218).
?DOC(" Initialize a `GroupNorm` with `num_groups` groups over `num_channels` channels.\n").
-spec group_norm_init(integer(), integer()) -> viva_tensor@nn@norm:group_norm().
group_norm_init(Num_groups, Num_channels) ->
    viva_tensor@nn@norm:group_norm_init(Num_groups, Num_channels).

-file("src/viva_tensor.gleam", 2224).
?DOC(
    " Forward pass for `GroupNorm` — supports `[batch, channels]` and\n"
    " `[batch, channels, spatial]` inputs.\n"
).
-spec group_norm_forward(
    viva_tensor@nn@norm:group_norm(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
group_norm_forward(Layer, Input) ->
    viva_tensor@nn@norm:group_norm_forward(Layer, Input).

-file("src/viva_tensor.gleam", 2233).
?DOC(" Default conv2d config (3x3 kernel, stride 1, no padding)\n").
-spec conv2d_config() -> viva_tensor@tensor:conv2d_config().
conv2d_config() ->
    viva_tensor@tensor:conv2d_config().

-file("src/viva_tensor.gleam", 2238).
?DOC(" Conv2d config with \"same\" padding\n").
-spec conv2d_same(integer(), integer()) -> viva_tensor@tensor:conv2d_config().
conv2d_same(Kernel_h, Kernel_w) ->
    viva_tensor@tensor:conv2d_same(Kernel_h, Kernel_w).

-file("src/viva_tensor.gleam", 2243).
?DOC(" 2D Convolution\n").
-spec conv2d(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:conv2d_config()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
conv2d(Input, Kernel, Config) ->
    viva_tensor@tensor:conv2d(Input, Kernel, Config).

-file("src/viva_tensor.gleam", 2252).
?DOC(" Pad 2D tensor with zeros\n").
-spec pad2d(viva_tensor@tensor:tensor(), integer(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
pad2d(T, Pad_h, Pad_w) ->
    viva_tensor@tensor:pad2d(T, Pad_h, Pad_w).

-file("src/viva_tensor.gleam", 2257).
?DOC(" Pad 4D tensor with zeros\n").
-spec pad4d(viva_tensor@tensor:tensor(), integer(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
pad4d(T, Pad_h, Pad_w) ->
    viva_tensor@tensor:pad4d(T, Pad_h, Pad_w).

-file("src/viva_tensor.gleam", 2262).
?DOC(" Max pooling 2D\n").
-spec max_pool2d(
    viva_tensor@tensor:tensor(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
max_pool2d(Input, Pool_h, Pool_w, Stride_h, Stride_w) ->
    viva_tensor@tensor:max_pool2d(Input, Pool_h, Pool_w, Stride_h, Stride_w).

-file("src/viva_tensor.gleam", 2273).
?DOC(" Average pooling 2D\n").
-spec avg_pool2d(
    viva_tensor@tensor:tensor(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
avg_pool2d(Input, Pool_h, Pool_w, Stride_h, Stride_w) ->
    viva_tensor@tensor:avg_pool2d(Input, Pool_h, Pool_w, Stride_h, Stride_w).

-file("src/viva_tensor.gleam", 2298).
?DOC(" Initialize a Conv1d layer with zero weights and bias.\n").
-spec conv1d_init(integer(), integer(), integer(), integer(), integer()) -> viva_tensor@nn@conv:conv1d_config().
conv1d_init(In_channels, Out_channels, Kernel_size, Stride, Padding) ->
    viva_tensor@nn@conv:conv1d_init(
        In_channels,
        Out_channels,
        Kernel_size,
        Stride,
        Padding
    ).

-file("src/viva_tensor.gleam", 2316).
?DOC(
    " 1D convolution forward pass. Output length =\n"
    " `(L_in + 2*padding - kernel) / stride + 1`.\n"
).
-spec conv1d_forward(
    viva_tensor@nn@conv:conv1d_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
conv1d_forward(Config, Input) ->
    viva_tensor@nn@conv:conv1d_forward(Config, Input).

-file("src/viva_tensor.gleam", 2324).
?DOC(" Initialize a Conv3d layer with zero weights and bias.\n").
-spec conv3d_init(
    integer(),
    integer(),
    {integer(), integer(), integer()},
    {integer(), integer(), integer()},
    {integer(), integer(), integer()}
) -> viva_tensor@nn@conv:conv3d_config().
conv3d_init(In_channels, Out_channels, Kernel_size, Stride, Padding) ->
    viva_tensor@nn@conv:conv3d_init(
        In_channels,
        Out_channels,
        Kernel_size,
        Stride,
        Padding
    ).

-file("src/viva_tensor.gleam", 2342).
?DOC(
    " 3D convolution forward pass. Output dim =\n"
    " `(In + 2*pad - kernel) / stride + 1` per spatial axis.\n"
).
-spec conv3d_forward(
    viva_tensor@nn@conv:conv3d_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
conv3d_forward(Config, Input) ->
    viva_tensor@nn@conv:conv3d_forward(Config, Input).

-file("src/viva_tensor.gleam", 2350).
?DOC(" Initialize a ConvTranspose2d layer with zero weights and bias.\n").
-spec conv_transpose_2d_init(
    integer(),
    integer(),
    {integer(), integer()},
    {integer(), integer()},
    {integer(), integer()},
    {integer(), integer()}
) -> viva_tensor@nn@conv:conv_transpose2d_config().
conv_transpose_2d_init(
    In_channels,
    Out_channels,
    Kernel_size,
    Stride,
    Padding,
    Output_padding
) ->
    viva_tensor@nn@conv:conv_transpose_2d_init(
        In_channels,
        Out_channels,
        Kernel_size,
        Stride,
        Padding,
        Output_padding
    ).

-file("src/viva_tensor.gleam", 2370).
?DOC(
    " 2D transposed convolution (deconv) forward pass. Output dim =\n"
    " `(In - 1) * stride - 2*padding + (kernel - 1) + output_padding + 1`.\n"
).
-spec conv_transpose_2d_forward(
    viva_tensor@nn@conv:conv_transpose2d_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
conv_transpose_2d_forward(Config, Input) ->
    viva_tensor@nn@conv:conv_transpose_2d_forward(Config, Input).

-file("src/viva_tensor.gleam", 2378).
?DOC(" Global average pooling\n").
-spec global_avg_pool2d(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
global_avg_pool2d(Input) ->
    viva_tensor@tensor:global_avg_pool2d(Input).

-file("src/viva_tensor.gleam", 2414).
?DOC(
    " Initialize a `Dropout` layer with drop probability `p`. Output shape: same\n"
    " as input.\n"
).
-spec dropout_init(float()) -> viva_tensor@nn@pool:dropout().
dropout_init(P) ->
    viva_tensor@nn@pool:dropout_init(P).

-file("src/viva_tensor.gleam", 2421).
?DOC(
    " Forward pass for inverted dropout. Output shape: same as input.\n"
    " Passthrough when `training = False` or `p == 0.0`. When `p == 1.0` every\n"
    " element is zeroed.\n"
).
-spec dropout_forward(
    viva_tensor@nn@pool:dropout(),
    viva_tensor@tensor:tensor(),
    boolean()
) -> viva_tensor@tensor:tensor().
dropout_forward(Layer, Input, Training) ->
    viva_tensor@nn@pool:dropout_forward(Layer, Input, Training).

-file("src/viva_tensor.gleam", 2431).
?DOC(
    " 1D max pooling. Input `[batch, channels, length]`, output\n"
    " `[batch, channels, (length + 2*padding - kernel_size) / stride + 1]`.\n"
).
-spec max_pool_1d_forward(
    viva_tensor@nn@pool:max_pool1d_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
max_pool_1d_forward(Config, Input) ->
    viva_tensor@nn@pool:max_pool_1d_forward(Config, Input).

-file("src/viva_tensor.gleam", 2440).
?DOC(
    " 1D average pooling. Input `[batch, channels, length]`, output\n"
    " `[batch, channels, (length + 2*padding - kernel_size) / stride + 1]`.\n"
).
-spec avg_pool_1d_forward(
    viva_tensor@nn@pool:avg_pool1d_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
avg_pool_1d_forward(Config, Input) ->
    viva_tensor@nn@pool:avg_pool_1d_forward(Config, Input).

-file("src/viva_tensor.gleam", 2449).
?DOC(
    " 2D adaptive average pooling. Input `[batch, channels, H, W]`, output\n"
    " `[batch, channels, output_h, output_w]`.\n"
).
-spec adaptive_avg_pool_2d_forward(
    viva_tensor@nn@pool:adaptive_avg_pool2d_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
adaptive_avg_pool_2d_forward(Config, Input) ->
    viva_tensor@nn@pool:adaptive_avg_pool_2d_forward(Config, Input).

-file("src/viva_tensor.gleam", 2458).
?DOC(
    " 1D adaptive average pooling. Input `[batch, channels, length]`, output\n"
    " `[batch, channels, output_size]`.\n"
).
-spec adaptive_avg_pool_1d_forward(
    viva_tensor@nn@pool:adaptive_avg_pool1d_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
adaptive_avg_pool_1d_forward(Config, Input) ->
    viva_tensor@nn@pool:adaptive_avg_pool_1d_forward(Config, Input).

-file("src/viva_tensor.gleam", 2467).
?DOC(
    " 2D upsampling (nearest or bilinear). Input `[batch, channels, H, W]`,\n"
    " output `[batch, channels, H * scale_factor, W * scale_factor]`.\n"
).
-spec upsample_forward(
    viva_tensor@nn@pool:upsample_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
upsample_forward(Config, Input) ->
    viva_tensor@nn@pool:upsample_forward(Config, Input).

-file("src/viva_tensor.gleam", 2480).
?DOC(
    " Run a 2D max-pool returning both pooled values and the flat argmax index\n"
    " per output cell. Input `[N, C, H, W]`; outputs are both\n"
    " `[N, C, H_out, W_out]`. Indices are stored as `Float` (truncated by the\n"
    " unpool consumer); fully-padded windows get `-1.0`.\n"
).
-spec max_pool_2d_with_indices(
    viva_tensor@tensor:tensor(),
    integer(),
    integer(),
    integer()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
max_pool_2d_with_indices(Input, Kernel_size, Stride, Padding) ->
    viva_tensor@nn@cv:max_pool_2d_with_indices(
        Input,
        Kernel_size,
        Stride,
        Padding
    ).

-file("src/viva_tensor.gleam", 2493).
?DOC(
    " Inverse of `max_pool_2d_with_indices`. Scatters pooled values back at the\n"
    " stored indices, zeros elsewhere. Input `[N, C, H_out, W_out]`, indices\n"
    " `[N, C, H_out, W_out]`, output `[N, C, H_in, W_in]` where `(H_in, W_in)`\n"
    " comes from `output_size`.\n"
).
-spec max_unpool_2d_forward(
    viva_tensor@nn@cv:max_unpool2d_config(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    {integer(), integer()}
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
max_unpool_2d_forward(Config, Input, Indices, Output_size) ->
    viva_tensor@nn@cv:max_unpool_2d_forward(Config, Input, Indices, Output_size).

-file("src/viva_tensor.gleam", 2505).
?DOC(
    " Greedy Non-Maximum Suppression. `boxes` `[N, 4]` (rows `[x1, y1, x2, y2]`),\n"
    " `scores` `[N]`. Returns the indices of kept boxes, sorted by descending\n"
    " score.\n"
).
-spec nms(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor(), float()) -> {ok,
        list(integer())} |
    {error, viva_tensor@core@error:tensor_error()}.
nms(Boxes, Scores, Iou_threshold) ->
    viva_tensor@nn@cv:nms(Boxes, Scores, Iou_threshold).

-file("src/viva_tensor.gleam", 2515).
?DOC(
    " Bilinear ROIAlign. `features` `[N, C, H, W]`, `rois` `[K, 5]` with rows\n"
    " `[batch_index, x1, y1, x2, y2]`. Output `[K, C, output_h, output_w]`.\n"
).
-spec roi_align(
    viva_tensor@nn@cv:roi_align_config(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
roi_align(Config, Features, Rois) ->
    viva_tensor@nn@cv:roi_align(Config, Features, Rois).

-file("src/viva_tensor.gleam", 2525).
?DOC(
    " Batched 2-D matmul `[Ba, M, K] @ [Bb, K, N] -> [max(Ba, Bb), M, N]` with\n"
    " broadcasting when either batch dim is `1`.\n"
).
-spec batched_matmul(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
batched_matmul(A, B) ->
    viva_tensor@nn@cv:batched_matmul(A, B).

-file("src/viva_tensor.gleam", 2532).
?DOC(
    " Initialize a `BatchNorm2d` with `scale = ones([C])`, `bias = zeros([C])`,\n"
    " `running_mean = zeros([C])`, `running_var = ones([C])`, `momentum = 0.1`,\n"
    " `eps = 1.0e-5`. `C = num_features`.\n"
).
-spec batch_norm_2d_init(integer()) -> viva_tensor@nn@cv:batch_norm2d().
batch_norm_2d_init(Num_features) ->
    viva_tensor@nn@cv:batch_norm_2d_init(Num_features).

-file("src/viva_tensor.gleam", 2539).
?DOC(
    " Forward pass for `BatchNorm2d`. Input `[B, C, H, W]`, output same shape.\n"
    " In training mode updates running stats via EMA; in eval mode uses them\n"
    " directly. Returns the (possibly updated) layer plus the output.\n"
).
-spec batch_norm_2d_forward(
    viva_tensor@nn@cv:batch_norm2d(),
    viva_tensor@tensor:tensor(),
    boolean()
) -> {ok, {viva_tensor@nn@cv:batch_norm2d(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
batch_norm_2d_forward(Layer, Input, Training) ->
    viva_tensor@nn@cv:batch_norm_2d_forward(Layer, Input, Training).

-file("src/viva_tensor.gleam", 2558).
?DOC(" Measure TFLOPS for a single matmul operation\n").
-spec measure_tflops(
    viva_tensor@native@tflops:backend(),
    integer(),
    integer(),
    integer()
) -> viva_tensor@native@tflops:tflops_result().
measure_tflops(Backend, M, N, K) ->
    viva_tensor@native@tflops:measure_matmul(Backend, M, N, K).

-file("src/viva_tensor.gleam", 2568).
?DOC(" Measure averaged TFLOPS (warmup + iterations)\n").
-spec measure_tflops_averaged(
    viva_tensor@native@tflops:backend(),
    integer(),
    integer(),
    integer(),
    integer()
) -> viva_tensor@native@tflops:tflops_result().
measure_tflops_averaged(Backend, M, N, K, Iterations) ->
    viva_tensor@native@tflops:measure_matmul_averaged(
        Backend,
        M,
        N,
        K,
        Iterations
    ).

-file("src/viva_tensor.gleam", 2609).
?DOC(" Inspect stable backend capability records.\n").
-spec backend_capabilities() -> list(backend_capability()).
backend_capabilities() ->
    Nif_loaded = viva_tensor@core@ffi:is_nif_loaded(),
    Zig_loaded = case Nif_loaded of
        true ->
            viva_tensor@core@ffi:zig_is_loaded();

        false ->
            false
    end,
    Backends = case Nif_loaded of
        true ->
            detect_backends();

        false ->
            [pure_erlang]
    end,
    build_backend_capabilities(Zig_loaded, Backends).

-file("src/viva_tensor.gleam", 2624).
?DOC(" Inspect hardware target profiles, including unavailable future targets.\n").
-spec hardware_profiles() -> list(viva_tensor@backend@capability:hardware_profile()).
hardware_profiles() ->
    Caps = capabilities(),
    viva_tensor@backend@capability:hardware_profiles(
        erlang:element(3, Caps),
        erlang:element(5, Caps)
    ).

-file("src/viva_tensor.gleam", 2630).
?DOC(" Describe a Rubin-ready NVFP4 block-scaled layout using 16-value micro-blocks.\n").
-spec nvfp4_block_scaled_layout(list(integer())) -> viva_tensor@quant@layout:quant_layout().
nvfp4_block_scaled_layout(Shape) ->
    viva_tensor@quant@layout:nvfp4_block_scaled(Shape).

-file("src/viva_tensor.gleam", 2635).
?DOC(" Describe an experimental progressive INT2 layout.\n").
-spec int2_progressive_layout(list(integer()), integer()) -> {ok,
        viva_tensor@quant@layout:quant_layout()} |
    {error, viva_tensor@core@error:tensor_error()}.
int2_progressive_layout(Shape, Block_size) ->
    viva_tensor@quant@layout:int2_progressive(Shape, Block_size).

-file("src/viva_tensor.gleam", 2643).
?DOC(" Describe an experimental progressive INT3 layout.\n").
-spec int3_progressive_layout(list(integer()), integer()) -> {ok,
        viva_tensor@quant@layout:quant_layout()} |
    {error, viva_tensor@core@error:tensor_error()}.
int3_progressive_layout(Shape, Block_size) ->
    viva_tensor@quant@layout:int3_progressive(Shape, Block_size).

-file("src/viva_tensor.gleam", 2651).
?DOC(" Estimate payload bytes for a quantized layout.\n").
-spec quant_layout_memory_bytes(viva_tensor@quant@layout:quant_layout()) -> integer().
quant_layout_memory_bytes(Layout) ->
    viva_tensor@quant@layout:memory_bytes(Layout).

-file("src/viva_tensor.gleam", 2656).
?DOC(" Estimate compression ratio versus a baseline element width.\n").
-spec quant_layout_compression_ratio_against(
    viva_tensor@quant@layout:quant_layout(),
    integer()
) -> float().
quant_layout_compression_ratio_against(Layout, Baseline_bits_per_value) ->
    viva_tensor@quant@layout:compression_ratio_against(
        Layout,
        Baseline_bits_per_value
    ).

-file("src/viva_tensor.gleam", 2664).
?DOC(" Check whether a layout matches Rubin-style native micro-block assumptions.\n").
-spec quant_layout_is_rubin_native_candidate(
    viva_tensor@quant@layout:quant_layout()
) -> boolean().
quant_layout_is_rubin_native_candidate(Layout) ->
    viva_tensor@quant@layout:is_rubin_native_candidate(Layout).

-file("src/viva_tensor.gleam", 2669).
?DOC(" Apply randomized normalized Hadamard preprocessing to a vector tensor.\n").
-spec try_hadamard_preprocess(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@quant@hadamard:hadamard_preprocess()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_hadamard_preprocess(Input, Seed) ->
    viva_tensor@quant@hadamard:try_preprocess(Input, Seed).

-file("src/viva_tensor.gleam", 2677).
?DOC(" Invert a previously applied Hadamard preprocessing plan.\n").
-spec try_inverse_hadamard_preprocess(
    viva_tensor@quant@hadamard:hadamard_preprocess()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
try_inverse_hadamard_preprocess(Preprocessed) ->
    viva_tensor@quant@hadamard:inverse(Preprocessed).

-file("src/viva_tensor.gleam", 2684).
?DOC(" Apply a normalized Walsh-Hadamard transform to power-of-two vector data.\n").
-spec try_normalized_walsh_hadamard(list(float())) -> {ok, list(float())} |
    {error, viva_tensor@core@error:tensor_error()}.
try_normalized_walsh_hadamard(Values) ->
    viva_tensor@quant@hadamard:try_normalized_walsh_hadamard(Values).

-file("src/viva_tensor.gleam", 2903).
-spec to_public_storage(viva_tensor@layout:tensor_storage()) -> tensor_storage().
to_public_storage(Storage) ->
    case Storage of
        dense_storage ->
            dense_storage;

        strided_storage ->
            strided_storage;

        native_storage ->
            native_storage
    end.

-file("src/viva_tensor.gleam", 2707).
?DOC(" Build a runtime spec from an existing tensor.\n").
-spec tensor_spec(viva_tensor@tensor:tensor()) -> tensor_spec().
tensor_spec(T) ->
    Metadata = viva_tensor@tensor:layout(T),
    {tensor_spec,
        erlang:element(5, Metadata),
        to_public_dtype(erlang:element(4, Metadata)),
        to_public_device(erlang:element(3, Metadata)),
        to_public_storage(erlang:element(2, Metadata)),
        case erlang:element(10, Metadata) of
            true ->
                row_major;

            false ->
                strided_layout
        end,
        erlang:element(9, Metadata),
        erlang:element(8, Metadata)}.

-file("src/viva_tensor.gleam", 2724).
?DOC(" Build a runtime spec from explicit metadata.\n").
-spec spec_from_parts(
    list(integer()),
    tensor_dtype(),
    tensor_device(),
    tensor_storage(),
    tensor_memory_layout()
) -> tensor_spec().
spec_from_parts(Shape, Dtype, Device, Storage, Memory_layout) ->
    {tensor_spec,
        Shape,
        Dtype,
        Device,
        Storage,
        Memory_layout,
        erlang:length(Shape),
        gleam@list:fold(Shape, 1, fun(Acc, Dim) -> Acc * Dim end)}.

-file("src/viva_tensor.gleam", 2743).
?DOC(" Stable dtype label used by runtime cache keys.\n").
-spec dtype_name(tensor_dtype()) -> binary().
dtype_name(Dtype) ->
    case Dtype of
        float64 ->
            <<"float64"/utf8>>;

        float32 ->
            <<"float32"/utf8>>;

        float16 ->
            <<"float16"/utf8>>;

        b_float16 ->
            <<"bfloat16"/utf8>>;

        float8_e4_m3 ->
            <<"float8_e4m3"/utf8>>;

        int8 ->
            <<"int8"/utf8>>;

        int4 ->
            <<"int4"/utf8>>;

        sparse_float16 ->
            <<"sparse_float16"/utf8>>
    end.

-file("src/viva_tensor.gleam", 2757).
?DOC(" Stable device label used by runtime cache keys.\n").
-spec device_name(tensor_device()) -> binary().
device_name(Device) ->
    case Device of
        beam_cpu ->
            <<"beam_cpu"/utf8>>;

        native_cpu ->
            <<"native_cpu"/utf8>>;

        {cuda_device, Index} ->
            <<"cuda:"/utf8, (erlang:integer_to_binary(Index))/binary>>
    end.

-file("src/viva_tensor.gleam", 2871).
-spec memory_layout_name(tensor_memory_layout()) -> binary().
memory_layout_name(Memory_layout) ->
    case Memory_layout of
        row_major ->
            <<"row_major"/utf8>>;

        column_major ->
            <<"column_major"/utf8>>;

        strided_layout ->
            <<"strided"/utf8>>;

        packed_fp8_layout ->
            <<"packed_fp8"/utf8>>;

        packed_sparse24_layout ->
            <<"packed_sparse24"/utf8>>
    end.

-file("src/viva_tensor.gleam", 2863).
-spec storage_name(tensor_storage()) -> binary().
storage_name(Storage) ->
    case Storage of
        dense_storage ->
            <<"dense"/utf8>>;

        strided_storage ->
            <<"strided"/utf8>>;

        native_storage ->
            <<"native"/utf8>>
    end.

-file("src/viva_tensor.gleam", 2855).
-spec shape_key(list(integer())) -> binary().
shape_key(Shape) ->
    case Shape of
        [] ->
            <<"scalar"/utf8>>;

        [Dim] ->
            erlang:integer_to_binary(Dim);

        [Dim@1 | Rest] ->
            <<<<(erlang:integer_to_binary(Dim@1))/binary, "x"/utf8>>/binary,
                (shape_key(Rest))/binary>>
    end.

-file("src/viva_tensor.gleam", 2766).
?DOC(" Stable tensor spec cache key.\n").
-spec spec_key(tensor_spec()) -> binary().
spec_key(Spec) ->
    <<<<<<<<<<<<<<<<(shape_key(erlang:element(2, Spec)))/binary, ":"/utf8>>/binary,
                                (dtype_name(erlang:element(3, Spec)))/binary>>/binary,
                            ":"/utf8>>/binary,
                        (device_name(erlang:element(4, Spec)))/binary>>/binary,
                    ":"/utf8>>/binary,
                (storage_name(erlang:element(5, Spec)))/binary>>/binary,
            ":"/utf8>>/binary,
        (memory_layout_name(erlang:element(6, Spec)))/binary>>.

-file("src/viva_tensor.gleam", 2832).
-spec runtime_op_key(runtime_op()) -> binary().
runtime_op_key(Operation) ->
    case Operation of
        runtime_elementwise ->
            <<"elementwise"/utf8>>;

        runtime_broadcast ->
            <<"broadcast"/utf8>>;

        runtime_reduction ->
            <<"reduction"/utf8>>;

        runtime_softmax ->
            <<"softmax"/utf8>>;

        {runtime_matmul, M, N, K} ->
            <<<<<<<<<<"matmul:"/utf8, (erlang:integer_to_binary(M))/binary>>/binary,
                            "x"/utf8>>/binary,
                        (erlang:integer_to_binary(N))/binary>>/binary,
                    "x"/utf8>>/binary,
                (erlang:integer_to_binary(K))/binary>>;

        {runtime_linear, Batch, In_features, Out_features} ->
            <<<<<<<<<<"linear:"/utf8, (erlang:integer_to_binary(Batch))/binary>>/binary,
                            "x"/utf8>>/binary,
                        (erlang:integer_to_binary(In_features))/binary>>/binary,
                    "x"/utf8>>/binary,
                (erlang:integer_to_binary(Out_features))/binary>>
    end.

-file("src/viva_tensor.gleam", 2828).
-spec runtime_cache_key_for(tensor_spec(), runtime_op()) -> binary().
runtime_cache_key_for(Spec, Operation) ->
    <<<<(spec_key(Spec))/binary, "|"/utf8>>/binary,
        (runtime_op_key(Operation))/binary>>.

-file("src/viva_tensor.gleam", 2985).
-spec runtime_backend_set() -> viva_tensor@runtime:runtime_backend_set(tensor_backend()).
runtime_backend_set() ->
    {runtime_backend_set,
        backend_pure_gleam,
        backend_zig_simd,
        backend_mkl,
        backend_cuda_fp32,
        backend_cuda_fp16,
        backend_cuda_int8,
        backend_cuda_sparse}.

-file("src/viva_tensor.gleam", 2891).
-spec to_internal_runtime_op(runtime_op()) -> viva_tensor@runtime:runtime_op().
to_internal_runtime_op(Operation) ->
    case Operation of
        runtime_elementwise ->
            runtime_elementwise;

        runtime_broadcast ->
            runtime_broadcast;

        runtime_reduction ->
            runtime_reduction;

        runtime_softmax ->
            runtime_softmax;

        {runtime_matmul, M, N, K} ->
            {runtime_matmul, M, N, K};

        {runtime_linear, Batch, In_features, Out_features} ->
            {runtime_linear, Batch, In_features, Out_features}
    end.

-file("src/viva_tensor.gleam", 2961).
-spec to_layout_memory_layout(tensor_memory_layout()) -> viva_tensor@layout:tensor_memory_layout().
to_layout_memory_layout(Memory_layout) ->
    case Memory_layout of
        row_major ->
            row_major;

        column_major ->
            column_major;

        strided_layout ->
            strided_layout;

        packed_fp8_layout ->
            packed_fp8_layout;

        packed_sparse24_layout ->
            packed_sparse24_layout
    end.

-file("src/viva_tensor.gleam", 2911).
-spec to_layout_storage(tensor_storage()) -> viva_tensor@layout:tensor_storage().
to_layout_storage(Storage) ->
    case Storage of
        dense_storage ->
            dense_storage;

        strided_storage ->
            strided_storage;

        native_storage ->
            native_storage
    end.

-file("src/viva_tensor.gleam", 2927).
-spec to_layout_device(tensor_device()) -> viva_tensor@layout:tensor_device().
to_layout_device(Device) ->
    case Device of
        beam_cpu ->
            beam_cpu;

        native_cpu ->
            native_cpu;

        {cuda_device, Index} ->
            {cuda_device, Index}
    end.

-file("src/viva_tensor.gleam", 2948).
-spec to_layout_dtype(tensor_dtype()) -> viva_tensor@layout:tensor_dtype().
to_layout_dtype(Dtype) ->
    case Dtype of
        float64 ->
            float64;

        float32 ->
            float32;

        float16 ->
            float16;

        b_float16 ->
            b_float16;

        float8_e4_m3 ->
            float8_e4_m3;

        int8 ->
            int8;

        int4 ->
            int4;

        sparse_float16 ->
            sparse_float16
    end.

-file("src/viva_tensor.gleam", 2881).
-spec to_internal_spec(tensor_spec()) -> viva_tensor@spec:tensor_spec().
to_internal_spec(Spec) ->
    viva_tensor@spec:spec_from_parts(
        erlang:element(2, Spec),
        to_layout_dtype(erlang:element(3, Spec)),
        to_layout_device(erlang:element(4, Spec)),
        to_layout_storage(erlang:element(5, Spec)),
        to_layout_memory_layout(erlang:element(6, Spec))
    ).

-file("src/viva_tensor.gleam", 2779).
?DOC(" Plan a runtime operation from dtype/device/layout metadata.\n").
-spec plan_runtime(tensor_spec(), runtime_op()) -> runtime_plan().
plan_runtime(Spec, Operation) ->
    Caps = capabilities(),
    Internal_plan = viva_tensor@runtime:plan_runtime(
        to_internal_spec(Spec),
        to_internal_runtime_op(Operation),
        available_backends_from_capabilities(erlang:element(6, Caps)),
        runtime_backend_set()
    ),
    {runtime_plan,
        Spec,
        Operation,
        erlang:element(4, Internal_plan),
        erlang:element(5, Internal_plan),
        gleam@list:map(
            erlang:element(6, Internal_plan),
            fun(Rejection) ->
                {runtime_rejection,
                    erlang:element(2, Rejection),
                    erlang:element(3, Rejection)}
            end
        ),
        erlang:element(7, Internal_plan),
        runtime_cache_key_for(Spec, Operation)}.

-file("src/viva_tensor.gleam", 2802).
?DOC(" Return the stable cache key for a runtime plan.\n").
-spec runtime_cache_key(runtime_plan()) -> binary().
runtime_cache_key(Plan) ->
    erlang:element(8, Plan).

-file("src/viva_tensor.gleam", 2807).
?DOC(" Return the stable cache key for a runtime plan.\n").
-spec cache_key(runtime_plan()) -> binary().
cache_key(Plan) ->
    runtime_cache_key(Plan).

-file("src/viva_tensor.gleam", 3164).
?DOC(" Mean Squared Error. See `viva_tensor/nn/losses.mse_loss`.\n").
-spec mse_loss(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
mse_loss(Prediction, Target, Reduction) ->
    viva_tensor@nn@losses:mse_loss(Prediction, Target, Reduction).

-file("src/viva_tensor.gleam", 3173).
?DOC(" L1 / Mean Absolute Error. See `viva_tensor/nn/losses.l1_loss`.\n").
-spec l1_loss(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
l1_loss(Prediction, Target, Reduction) ->
    viva_tensor@nn@losses:l1_loss(Prediction, Target, Reduction).

-file("src/viva_tensor.gleam", 3182).
?DOC(" Binary Cross-Entropy. See `viva_tensor/nn/losses.bce_loss`.\n").
-spec bce_loss(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
bce_loss(Prediction, Target, Reduction) ->
    viva_tensor@nn@losses:bce_loss(Prediction, Target, Reduction).

-file("src/viva_tensor.gleam", 3192).
?DOC(
    " Softmax cross-entropy with integer-valued class targets. See\n"
    " `viva_tensor/nn/losses.cross_entropy_loss`.\n"
).
-spec cross_entropy_loss(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
cross_entropy_loss(Logits, Targets, Reduction) ->
    viva_tensor@nn@losses:cross_entropy_loss(Logits, Targets, Reduction).

-file("src/viva_tensor.gleam", 3201).
?DOC(" Huber loss (smooth L1). See `viva_tensor/nn/losses.huber_loss`.\n").
-spec huber_loss(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    float(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
huber_loss(Prediction, Target, Delta, Reduction) ->
    viva_tensor@nn@losses:huber_loss(Prediction, Target, Delta, Reduction).

-file("src/viva_tensor.gleam", 3236).
?DOC(" Vanilla stochastic gradient descent. See `viva_tensor/nn/optim`.\n").
-spec sgd(float()) -> viva_tensor@nn@optim:optimizer().
sgd(Lr) ->
    viva_tensor@nn@optim:sgd(Lr).

-file("src/viva_tensor.gleam", 3241).
?DOC(" SGD with momentum. See `viva_tensor/nn/optim`.\n").
-spec sgd_momentum(float(), float()) -> viva_tensor@nn@optim:optimizer().
sgd_momentum(Lr, Momentum) ->
    viva_tensor@nn@optim:sgd_momentum(Lr, Momentum).

-file("src/viva_tensor.gleam", 3246).
?DOC(" RMSprop. See `viva_tensor/nn/optim`.\n").
-spec rmsprop(float(), float(), float()) -> viva_tensor@nn@optim:optimizer().
rmsprop(Lr, Alpha, Eps) ->
    viva_tensor@nn@optim:rmsprop(Lr, Alpha, Eps).

-file("src/viva_tensor.gleam", 3251).
?DOC(" Adam (Kingma & Ba, 2015). See `viva_tensor/nn/optim`.\n").
-spec adam(float()) -> viva_tensor@nn@optim:optimizer().
adam(Lr) ->
    viva_tensor@nn@optim:adam(Lr).

-file("src/viva_tensor.gleam", 3256).
?DOC(" AdamW (Loshchilov & Hutter, 2019). See `viva_tensor/nn/optim`.\n").
-spec adamw(float(), float()) -> viva_tensor@nn@optim:optimizer().
adamw(Lr, Weight_decay) ->
    viva_tensor@nn@optim:adamw(Lr, Weight_decay).

-file("src/viva_tensor.gleam", 3261).
?DOC(" Apply one optimizer step. See `viva_tensor/nn/optim.step`.\n").
-spec step(
    viva_tensor@nn@optim:optimizer(),
    list(viva_tensor@nn@optim:param()),
    list(viva_tensor@nn@optim:grad_pair())
) -> {ok,
        {viva_tensor@nn@optim:optimizer(), list(viva_tensor@nn@optim:param())}} |
    {error, viva_tensor@core@error:tensor_error()}.
step(Opt, Params, Grads) ->
    viva_tensor@nn@optim:step(Opt, Params, Grads).

-file("src/viva_tensor.gleam", 3270).
?DOC(" Zero every gradient tensor, preserving shapes. See `viva_tensor/nn/optim.zero_grad`.\n").
-spec zero_grad(list(viva_tensor@nn@optim:grad_pair())) -> list(viva_tensor@nn@optim:grad_pair()).
zero_grad(Grads) ->
    viva_tensor@nn@optim:zero_grad(Grads).

-file("src/viva_tensor.gleam", 3282).
?DOC(
    " Sigmoid activation: `1 / (1 + exp(-x))`. Numerically stable for large\n"
    " negative inputs via `exp(x) / (1 + exp(x))`.\n"
).
-spec sigmoid(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
sigmoid(T) ->
    viva_tensor@nn@activations:sigmoid(T).

-file("src/viva_tensor.gleam", 3287).
?DOC(" Hyperbolic tangent activation. Output range `(-1, 1)`.\n").
-spec tanh(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
tanh(T) ->
    viva_tensor@nn@activations:tanh(T).

-file("src/viva_tensor.gleam", 3292).
?DOC(" Rectified Linear Unit: `max(0, x)`.\n").
-spec relu(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
relu(T) ->
    viva_tensor@nn@activations:relu(T).

-file("src/viva_tensor.gleam", 3297).
?DOC(" Leaky ReLU: `x` if `x > 0` else `negative_slope * x`.\n").
-spec leaky_relu(viva_tensor@tensor:tensor(), float()) -> viva_tensor@tensor:tensor().
leaky_relu(T, Negative_slope) ->
    viva_tensor@nn@activations:leaky_relu(T, Negative_slope).

-file("src/viva_tensor.gleam", 3302).
?DOC(" Exponential Linear Unit: `x` if `x > 0` else `alpha * (exp(x) - 1)`.\n").
-spec elu(viva_tensor@tensor:tensor(), float()) -> viva_tensor@tensor:tensor().
elu(T, Alpha) ->
    viva_tensor@nn@activations:elu(T, Alpha).

-file("src/viva_tensor.gleam", 3307).
?DOC(" Scaled ELU with the canonical SELU constants from Klambauer et al. (2017).\n").
-spec selu(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
selu(T) ->
    viva_tensor@nn@activations:selu(T).

-file("src/viva_tensor.gleam", 3313).
?DOC(
    " Gaussian Error Linear Unit: `0.5 * x * (1 + erf(x / sqrt(2)))`.\n"
    " Uses the exact `erf`-based formulation.\n"
).
-spec gelu(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
gelu(T) ->
    viva_tensor@nn@activations:gelu(T).

-file("src/viva_tensor.gleam", 3318).
?DOC(" Swish / SiLU: `x * sigmoid(x)`.\n").
-spec swish(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
swish(T) ->
    viva_tensor@nn@activations:swish(T).

-file("src/viva_tensor.gleam", 3323).
?DOC(" Mish: `x * tanh(softplus(x))`.\n").
-spec mish(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
mish(T) ->
    viva_tensor@nn@activations:mish(T).

-file("src/viva_tensor.gleam", 3328).
?DOC(" Softplus: `log(1 + exp(x))`, numerically stable.\n").
-spec softplus(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
softplus(T) ->
    viva_tensor@nn@activations:softplus(T).

-file("src/viva_tensor.gleam", 3333).
?DOC(" Softmax along `axis`: `exp(x - max) / sum(exp(x - max))`.\n").
-spec softmax(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
softmax(T, Axis) ->
    viva_tensor@nn@activations:softmax(T, Axis).

-file("src/viva_tensor.gleam", 3338).
?DOC(" Log-softmax along `axis`: `x - max - log(sum(exp(x - max)))`.\n").
-spec log_softmax(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
log_softmax(T, Axis) ->
    viva_tensor@nn@activations:log_softmax(T, Axis).

-file("src/viva_tensor.gleam", 3343).
?DOC(" HardSwish: `x * relu6(x + 3) / 6`.\n").
-spec hardswish(viva_tensor@tensor:tensor()) -> viva_tensor@tensor:tensor().
hardswish(T) ->
    viva_tensor@nn@activations:hardswish(T).

-file("src/viva_tensor.gleam", 3348).
?DOC(" HardTanh: `clamp(x, min_val, max_val)`.\n").
-spec hardtanh(viva_tensor@tensor:tensor(), float(), float()) -> viva_tensor@tensor:tensor().
hardtanh(T, Min_val, Max_val) ->
    viva_tensor@nn@activations:hardtanh(T, Min_val, Max_val).

-file("src/viva_tensor.gleam", 3362).
?DOC(" Backward for `relu`. See `viva_tensor/nn/backward.relu_backward`.\n").
-spec relu_backward(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
relu_backward(Grad_out, Input) ->
    viva_tensor@nn@backward:relu_backward(Grad_out, Input).

-file("src/viva_tensor.gleam", 3371).
?DOC(
    " Backward for `sigmoid`. Takes the sigmoid **output**, not the original\n"
    " input. See `viva_tensor/nn/backward.sigmoid_backward`.\n"
).
-spec sigmoid_backward(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
sigmoid_backward(Grad_out, Output) ->
    viva_tensor@nn@backward:sigmoid_backward(Grad_out, Output).

-file("src/viva_tensor.gleam", 3380).
?DOC(
    " Backward for `tanh`. Takes the tanh **output**, not the original input.\n"
    " See `viva_tensor/nn/backward.tanh_backward`.\n"
).
-spec tanh_backward(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
tanh_backward(Grad_out, Output) ->
    viva_tensor@nn@backward:tanh_backward(Grad_out, Output).

-file("src/viva_tensor.gleam", 3388).
?DOC(" Backward for exact `gelu`. See `viva_tensor/nn/backward.gelu_backward`.\n").
-spec gelu_backward(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
gelu_backward(Grad_out, Input) ->
    viva_tensor@nn@backward:gelu_backward(Grad_out, Input).

-file("src/viva_tensor.gleam", 3396).
?DOC(" Backward for `leaky_relu`. See `viva_tensor/nn/backward.leaky_relu_backward`.\n").
-spec leaky_relu_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    float()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
leaky_relu_backward(Grad_out, Input, Negative_slope) ->
    viva_tensor@nn@backward:leaky_relu_backward(Grad_out, Input, Negative_slope).

-file("src/viva_tensor.gleam", 3405).
?DOC(" Backward for `elu`. See `viva_tensor/nn/backward.elu_backward`.\n").
-spec elu_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    float()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
elu_backward(Grad_out, Input, Alpha) ->
    viva_tensor@nn@backward:elu_backward(Grad_out, Input, Alpha).

-file("src/viva_tensor.gleam", 3415).
?DOC(
    " Backward for `mse_loss`. Returns gradient w.r.t. `prediction` only.\n"
    " See `viva_tensor/nn/backward.mse_loss_backward`.\n"
).
-spec mse_loss_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
mse_loss_backward(Grad_out, Prediction, Target, Reduction) ->
    viva_tensor@nn@backward:mse_loss_backward(
        Grad_out,
        Prediction,
        Target,
        Reduction
    ).

-file("src/viva_tensor.gleam", 3426).
?DOC(
    " Backward for `l1_loss`. Returns gradient w.r.t. `prediction` only.\n"
    " See `viva_tensor/nn/backward.l1_loss_backward`.\n"
).
-spec l1_loss_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
l1_loss_backward(Grad_out, Prediction, Target, Reduction) ->
    viva_tensor@nn@backward:l1_loss_backward(
        Grad_out,
        Prediction,
        Target,
        Reduction
    ).

-file("src/viva_tensor.gleam", 3437).
?DOC(
    " Backward for `bce_loss`. Returns gradient w.r.t. `prediction` only.\n"
    " See `viva_tensor/nn/backward.bce_loss_backward`.\n"
).
-spec bce_loss_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
bce_loss_backward(Grad_out, Prediction, Target, Reduction) ->
    viva_tensor@nn@backward:bce_loss_backward(
        Grad_out,
        Prediction,
        Target,
        Reduction
    ).

-file("src/viva_tensor.gleam", 3448).
?DOC(
    " Backward for `cross_entropy_loss`. Returns gradient w.r.t. `logits`.\n"
    " See `viva_tensor/nn/backward.cross_entropy_loss_backward`.\n"
).
-spec cross_entropy_loss_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@nn@losses:reduction()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
cross_entropy_loss_backward(Grad_out, Logits, Targets, Reduction) ->
    viva_tensor@nn@backward:cross_entropy_loss_backward(
        Grad_out,
        Logits,
        Targets,
        Reduction
    ).

-file("src/viva_tensor.gleam", 3459).
?DOC(
    " Backward for a linear layer `output = input @ weight`. Returns\n"
    " `#(grad_input, grad_weight)`. See `viva_tensor/nn/backward.linear_backward`.\n"
).
-spec linear_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_backward(Grad_out, Input, Weight) ->
    viva_tensor@nn@backward:linear_backward(Grad_out, Input, Weight).

-file("src/viva_tensor.gleam", 3470).
?DOC(
    " Backward for `matmul`. Returns `#(grad_a, grad_b)`. Same math as\n"
    " `linear_backward`, exposed for the user-facing matmul.\n"
    " See `viva_tensor/nn/backward.matmul_backward`.\n"
).
-spec matmul_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
matmul_backward(Grad_out, A, B) ->
    viva_tensor@nn@backward:matmul_backward(Grad_out, A, B).

-file("src/viva_tensor.gleam", 3481).
?DOC(
    " Backward for `layer_norm` over the last dimension. Requires the `mean`\n"
    " and `variance` saved from the forward pass.\n"
    " See `viva_tensor/nn/backward.layer_norm_backward`.\n"
).
-spec layer_norm_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    float()
) -> {ok,
        {viva_tensor@tensor:tensor(),
            viva_tensor@tensor:tensor(),
            viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
layer_norm_backward(Grad_out, Input, Scale, Mean, Variance, Eps) ->
    viva_tensor@nn@backward:layer_norm_backward(
        Grad_out,
        Input,
        Scale,
        Mean,
        Variance,
        Eps
    ).

-file("src/viva_tensor.gleam", 3495).
?DOC(
    " Backward for `rms_norm` over the last dimension. Requires the `rms`\n"
    " saved from the forward pass. `eps` is retained for signature symmetry.\n"
    " See `viva_tensor/nn/backward.rms_norm_backward`.\n"
).
-spec rms_norm_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    float()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
rms_norm_backward(Grad_out, Input, Scale, Rms, Eps) ->
    viva_tensor@nn@backward:rms_norm_backward(Grad_out, Input, Scale, Rms, Eps).

-file("src/viva_tensor.gleam", 3507).
?DOC(
    " Backward for `softmax` along `axis`. Takes the softmax **output** of the\n"
    " forward pass. See `viva_tensor/nn/backward.softmax_backward`.\n"
).
-spec softmax_backward(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
softmax_backward(Grad_out, Output, Axis) ->
    viva_tensor@nn@backward:softmax_backward(Grad_out, Output, Axis).

-file("src/viva_tensor.gleam", 3522).
?DOC(" `softmax((Q @ K^T) / sqrt(d_k)) @ V`. See nn/attention docs.\n").
-spec scaled_dot_product_attention(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    gleam@option:option(viva_tensor@tensor:tensor()),
    boolean()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
scaled_dot_product_attention(Q, K, V, Mask, Is_causal) ->
    viva_tensor@nn@attention:scaled_dot_product_attention(
        Q,
        K,
        V,
        Mask,
        Is_causal
    ).

-file("src/viva_tensor.gleam", 3533).
?DOC(" Initialize a Multi-Head Attention module with zero weights.\n").
-spec multi_head_attention_init(integer(), integer(), boolean()) -> {ok,
        viva_tensor@nn@attention:multi_head_attention()} |
    {error, viva_tensor@core@error:tensor_error()}.
multi_head_attention_init(Num_heads, Embed_dim, Use_bias) ->
    viva_tensor@nn@attention:multi_head_attention_init(
        Num_heads,
        Embed_dim,
        Use_bias
    ).

-file("src/viva_tensor.gleam", 3542).
?DOC(" Multi-Head Attention forward pass.\n").
-spec multi_head_attention_forward(
    viva_tensor@nn@attention:multi_head_attention(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    boolean()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
multi_head_attention_forward(Mha, Q, K, V, Is_causal) ->
    viva_tensor@nn@attention:multi_head_attention_forward(
        Mha,
        Q,
        K,
        V,
        Is_causal
    ).

-file("src/viva_tensor.gleam", 3553).
?DOC(" Lower-triangular `[seq_len, seq_len]` mask of `1.0`s used by causal SDPA.\n").
-spec causal_mask(integer()) -> viva_tensor@tensor:tensor().
causal_mask(Seq_len) ->
    viva_tensor@nn@attention:causal_mask(Seq_len).

-file("src/viva_tensor.gleam", 3572).
?DOC(" Build an Elman RNN cell with Xavier-initialized weights and zero biases.\n").
-spec rnn_cell_init(integer(), integer()) -> viva_tensor@nn@rnn:rnn_cell().
rnn_cell_init(Input_size, Hidden_size) ->
    viva_tensor@nn@rnn:rnn_cell_init(Input_size, Hidden_size).

-file("src/viva_tensor.gleam", 3577).
?DOC(" Build a GRU cell with Xavier-initialized stacked weights and zero biases.\n").
-spec gru_cell_init(integer(), integer()) -> viva_tensor@nn@rnn:gru_cell().
gru_cell_init(Input_size, Hidden_size) ->
    viva_tensor@nn@rnn:gru_cell_init(Input_size, Hidden_size).

-file("src/viva_tensor.gleam", 3582).
?DOC(" Build an LSTM cell with Xavier-initialized stacked weights and zero biases.\n").
-spec lstm_cell_init(integer(), integer()) -> viva_tensor@nn@rnn:lstm_cell().
lstm_cell_init(Input_size, Hidden_size) ->
    viva_tensor@nn@rnn:lstm_cell_init(Input_size, Hidden_size).

-file("src/viva_tensor.gleam", 3587).
?DOC(" One Elman RNN time step: `h' = tanh(W_ih @ x + b_ih + W_hh @ h + b_hh)`.\n").
-spec rnn_cell_step(
    viva_tensor@nn@rnn:rnn_cell(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
rnn_cell_step(Cell, Input, Hidden) ->
    viva_tensor@nn@rnn:rnn_cell_step(Cell, Input, Hidden).

-file("src/viva_tensor.gleam", 3596).
?DOC(" One GRU time step (PyTorch `nn.GRUCell` convention).\n").
-spec gru_cell_step(
    viva_tensor@nn@rnn:gru_cell(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
gru_cell_step(Cell, Input, Hidden) ->
    viva_tensor@nn@rnn:gru_cell_step(Cell, Input, Hidden).

-file("src/viva_tensor.gleam", 3605).
?DOC(" One LSTM time step. Returns `(new_hidden, new_cell_state)`.\n").
-spec lstm_cell_step(
    viva_tensor@nn@rnn:lstm_cell(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
lstm_cell_step(Cell, Input, Hidden, Cell_state) ->
    viva_tensor@nn@rnn:lstm_cell_step(Cell, Input, Hidden, Cell_state).

-file("src/viva_tensor.gleam", 3615).
?DOC(" Run an Elman RNN cell over a list of time steps.\n").
-spec rnn_sequence(
    viva_tensor@nn@rnn:rnn_cell(),
    list(viva_tensor@tensor:tensor()),
    viva_tensor@tensor:tensor()
) -> {ok, {list(viva_tensor@tensor:tensor()), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
rnn_sequence(Cell, Inputs, Initial_hidden) ->
    viva_tensor@nn@rnn:rnn_sequence(Cell, Inputs, Initial_hidden).

-file("src/viva_tensor.gleam", 3624).
?DOC(" Run a GRU cell over a list of time steps.\n").
-spec gru_sequence(
    viva_tensor@nn@rnn:gru_cell(),
    list(viva_tensor@tensor:tensor()),
    viva_tensor@tensor:tensor()
) -> {ok, {list(viva_tensor@tensor:tensor()), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
gru_sequence(Cell, Inputs, Initial_hidden) ->
    viva_tensor@nn@rnn:gru_sequence(Cell, Inputs, Initial_hidden).

-file("src/viva_tensor.gleam", 3634).
?DOC(
    " Run an LSTM cell over a list of time steps. Returns\n"
    " `(all_hidden_states, final_hidden, final_cell_state)`.\n"
).
-spec lstm_sequence(
    viva_tensor@nn@rnn:lstm_cell(),
    list(viva_tensor@tensor:tensor()),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok,
        {list(viva_tensor@tensor:tensor()),
            viva_tensor@tensor:tensor(),
            viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
lstm_sequence(Cell, Inputs, Initial_hidden, Initial_cell) ->
    viva_tensor@nn@rnn:lstm_sequence(Cell, Inputs, Initial_hidden, Initial_cell).

-file("src/viva_tensor.gleam", 3655).
?DOC(
    " Build an in-memory dataset from a list of labeled samples.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let x = t.from_list([1.0])\n"
    " let y = t.from_list([0.0])\n"
    " let _ds = t.dataset_from_samples([t.Sample(input: x, target: y)])\n"
    " ```\n"
).
-spec dataset_from_samples(list(viva_tensor@data@dataloader:sample())) -> viva_tensor@data@dataloader:dataset().
dataset_from_samples(Samples) ->
    viva_tensor@data@dataloader:dataset_from_samples(Samples).

-file("src/viva_tensor.gleam", 3668).
?DOC(
    " Build a dataset from parallel input and target tensor lists.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let assert Ok(_ds) =\n"
    "   t.dataset_from_lists([t.from_list([1.0])], [t.from_list([0.0])])\n"
    " ```\n"
).
-spec dataset_from_lists(
    list(viva_tensor@tensor:tensor()),
    list(viva_tensor@tensor:tensor())
) -> {ok, viva_tensor@data@dataloader:dataset()} |
    {error, viva_tensor@core@error:tensor_error()}.
dataset_from_lists(Inputs, Targets) ->
    viva_tensor@data@dataloader:dataset_from_lists(Inputs, Targets).

-file("src/viva_tensor.gleam", 3683).
?DOC(
    " Number of samples in the dataset.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.dataset_len(t.dataset_from_samples([]))\n"
    " ```\n"
).
-spec dataset_len(viva_tensor@data@dataloader:dataset()) -> integer().
dataset_len(D) ->
    viva_tensor@data@dataloader:dataset_len(D).

-file("src/viva_tensor.gleam", 3699).
?DOC(
    " Fetch the i-th sample (zero-indexed; negative indices wrap).\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let ds =\n"
    "   t.dataset_from_samples([\n"
    "     t.Sample(input: t.from_list([1.0]), target: t.from_list([0.0])),\n"
    "   ])\n"
    " let assert Ok(_) = t.dataset_get(ds, -1)\n"
    " ```\n"
).
-spec dataset_get(viva_tensor@data@dataloader:dataset(), integer()) -> {ok,
        viva_tensor@data@dataloader:sample()} |
    {error, viva_tensor@core@error:tensor_error()}.
dataset_get(D, Index) ->
    viva_tensor@data@dataloader:dataset_get(D, Index).

-file("src/viva_tensor.gleam", 3711).
?DOC(
    " Create a new data loader.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.data_loader_new(t.dataset_from_samples([]), 32, True, False)\n"
    " ```\n"
).
-spec data_loader_new(
    viva_tensor@data@dataloader:dataset(),
    integer(),
    boolean(),
    boolean()
) -> viva_tensor@data@dataloader:data_loader().
data_loader_new(Dataset, Batch_size, Shuffle, Drop_last) ->
    viva_tensor@data@dataloader:data_loader_new(
        Dataset,
        Batch_size,
        Shuffle,
        Drop_last
    ).

-file("src/viva_tensor.gleam", 3733).
?DOC(
    " Iterate the loader once, returning all batches.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let ds =\n"
    "   t.dataset_from_samples([\n"
    "     t.Sample(input: t.from_list([1.0]), target: t.from_list([0.0])),\n"
    "   ])\n"
    " let loader = t.data_loader_new(ds, 1, False, False)\n"
    " let assert Ok(_) = t.data_loader_batches(loader)\n"
    " ```\n"
).
-spec data_loader_batches(viva_tensor@data@dataloader:data_loader()) -> {ok,
        list(viva_tensor@data@dataloader:batch())} |
    {error, viva_tensor@core@error:tensor_error()}.
data_loader_batches(Loader) ->
    viva_tensor@data@dataloader:data_loader_batches(Loader).

-file("src/viva_tensor.gleam", 3748).
?DOC(
    " Total number of batches a single iteration will yield.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let loader = t.data_loader_new(t.dataset_from_samples([]), 4, False, False)\n"
    " let _ = t.data_loader_len(loader)\n"
    " ```\n"
).
-spec data_loader_len(viva_tensor@data@dataloader:data_loader()) -> integer().
data_loader_len(Loader) ->
    viva_tensor@data@dataloader:data_loader_len(Loader).

-file("src/viva_tensor.gleam", 3764).
?DOC(" StepLR: `lr = base_lr * gamma^floor(step / step_size)` — staircase decay.\n").
-spec step_lr(float(), integer(), float()) -> viva_tensor@nn@scheduler:scheduler().
step_lr(Base_lr, Step_size, Gamma) ->
    viva_tensor@nn@scheduler:step_lr(Base_lr, Step_size, Gamma).

-file("src/viva_tensor.gleam", 3770).
?DOC(
    " CosineAnnealingLR: half-cosine from `base_lr` down to `eta_min` over\n"
    " `t_max` steps.\n"
).
-spec cosine_annealing_lr(float(), integer(), float()) -> viva_tensor@nn@scheduler:scheduler().
cosine_annealing_lr(Base_lr, T_max, Eta_min) ->
    viva_tensor@nn@scheduler:cosine_annealing_lr(Base_lr, T_max, Eta_min).

-file("src/viva_tensor.gleam", 3780).
?DOC(
    " LinearWarmup: linear ramp from 0 to `base_lr` over `warmup_steps`, then\n"
    " constant `base_lr`.\n"
).
-spec linear_warmup(float(), integer()) -> viva_tensor@nn@scheduler:scheduler().
linear_warmup(Base_lr, Warmup_steps) ->
    viva_tensor@nn@scheduler:linear_warmup(Base_lr, Warmup_steps).

-file("src/viva_tensor.gleam", 3786).
?DOC(
    " OneCycleLR: linear warmup `base_lr -> max_lr` for the first\n"
    " `pct_start * total_steps` steps, then cosine anneal `max_lr -> base_lr`.\n"
).
-spec one_cycle_lr(float(), float(), integer(), float()) -> viva_tensor@nn@scheduler:scheduler().
one_cycle_lr(Base_lr, Max_lr, Total_steps, Pct_start) ->
    viva_tensor@nn@scheduler:one_cycle_lr(
        Base_lr,
        Max_lr,
        Total_steps,
        Pct_start
    ).

-file("src/viva_tensor.gleam", 3796).
?DOC(" ExponentialLR: `lr = base_lr * gamma^step` — smooth exponential decay.\n").
-spec exponential_lr(float(), float()) -> viva_tensor@nn@scheduler:scheduler().
exponential_lr(Base_lr, Gamma) ->
    viva_tensor@nn@scheduler:exponential_lr(Base_lr, Gamma).

-file("src/viva_tensor.gleam", 3801).
?DOC(" Advance the scheduler by one step and return the new learning rate.\n").
-spec scheduler_step(viva_tensor@nn@scheduler:scheduler()) -> {viva_tensor@nn@scheduler:scheduler(),
    float()}.
scheduler_step(S) ->
    viva_tensor@nn@scheduler:scheduler_step(S).

-file("src/viva_tensor.gleam", 3807).
?DOC(
    " Compute the learning rate at the scheduler's current step without\n"
    " advancing.\n"
).
-spec scheduler_lr(viva_tensor@nn@scheduler:scheduler()) -> float().
scheduler_lr(S) ->
    viva_tensor@nn@scheduler:scheduler_lr(S).

-file("src/viva_tensor.gleam", 3813).
?DOC(
    " Apply the scheduler's next learning rate to an optimizer. Advances the\n"
    " scheduler and returns the updated `(scheduler, optimizer)` pair.\n"
).
-spec apply_to_optimizer(
    viva_tensor@nn@scheduler:scheduler(),
    viva_tensor@nn@optim:optimizer()
) -> {viva_tensor@nn@scheduler:scheduler(), viva_tensor@nn@optim:optimizer()}.
apply_to_optimizer(S, Opt) ->
    viva_tensor@nn@scheduler:apply_to_optimizer(S, Opt).

-file("src/viva_tensor.gleam", 3850).
?DOC(
    " Build a `WhitespaceTokenizer` from an ordered vocabulary list.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.whitespace_tokenizer_from_vocab(\n"
    "   [\"[PAD]\", \"[UNK]\", \"hello\"],\n"
    "   \"[UNK]\",\n"
    "   \"[PAD]\",\n"
    " )\n"
    " ```\n"
).
-spec whitespace_tokenizer_from_vocab(list(binary()), binary(), binary()) -> viva_tensor@text@tokenizer:whitespace_tokenizer().
whitespace_tokenizer_from_vocab(Vocab, Unk_token, Pad_token) ->
    viva_tensor@text@tokenizer:whitespace_tokenizer_from_vocab(
        Vocab,
        Unk_token,
        Pad_token
    ).

-file("src/viva_tensor.gleam", 3871).
?DOC(
    " Encode text with a `WhitespaceTokenizer`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.whitespace_tokenizer_from_vocab(\n"
    "   [\"[PAD]\", \"[UNK]\", \"hello\"],\n"
    "   \"[UNK]\",\n"
    "   \"[PAD]\",\n"
    " )\n"
    " let _ = t.whitespace_encode(tok, \"hello\")\n"
    " ```\n"
).
-spec whitespace_encode(
    viva_tensor@text@tokenizer:whitespace_tokenizer(),
    binary()
) -> list(integer()).
whitespace_encode(Tokenizer, Text) ->
    viva_tensor@text@tokenizer:whitespace_encode(Tokenizer, Text).

-file("src/viva_tensor.gleam", 3891).
?DOC(
    " Decode ids with a `WhitespaceTokenizer`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.whitespace_tokenizer_from_vocab(\n"
    "   [\"[PAD]\", \"[UNK]\", \"hello\"],\n"
    "   \"[UNK]\",\n"
    "   \"[PAD]\",\n"
    " )\n"
    " let _ = t.whitespace_decode(tok, [2])\n"
    " ```\n"
).
-spec whitespace_decode(
    viva_tensor@text@tokenizer:whitespace_tokenizer(),
    list(integer())
) -> binary().
whitespace_decode(Tokenizer, Ids) ->
    viva_tensor@text@tokenizer:whitespace_decode(Tokenizer, Ids).

-file("src/viva_tensor.gleam", 3906).
?DOC(
    " Build a `CharTokenizer` from an alphabet.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.char_tokenizer_from_alphabet([\"?\", \"a\", \"b\"], \"?\")\n"
    " ```\n"
).
-spec char_tokenizer_from_alphabet(list(binary()), binary()) -> viva_tensor@text@tokenizer:char_tokenizer().
char_tokenizer_from_alphabet(Alphabet, Unk_token) ->
    viva_tensor@text@tokenizer:char_tokenizer_from_alphabet(Alphabet, Unk_token).

-file("src/viva_tensor.gleam", 3922).
?DOC(
    " Encode text with a `CharTokenizer`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.char_tokenizer_from_alphabet([\"?\", \"a\", \"b\"], \"?\")\n"
    " let _ = t.char_encode(tok, \"ab\")\n"
    " ```\n"
).
-spec char_encode(viva_tensor@text@tokenizer:char_tokenizer(), binary()) -> list(integer()).
char_encode(Tokenizer, Text) ->
    viva_tensor@text@tokenizer:char_encode(Tokenizer, Text).

-file("src/viva_tensor.gleam", 3935).
?DOC(
    " Decode ids with a `CharTokenizer`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.char_tokenizer_from_alphabet([\"?\", \"a\", \"b\"], \"?\")\n"
    " let _ = t.char_decode(tok, [1, 2])\n"
    " ```\n"
).
-spec char_decode(viva_tensor@text@tokenizer:char_tokenizer(), list(integer())) -> binary().
char_decode(Tokenizer, Ids) ->
    viva_tensor@text@tokenizer:char_decode(Tokenizer, Ids).

-file("src/viva_tensor.gleam", 3953).
?DOC(
    " Build a `WordPieceTokenizer` from an ordered vocabulary list.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.word_piece_tokenizer_from_vocab(\n"
    "   [\"[PAD]\", \"[UNK]\", \"[CLS]\", \"[SEP]\", \"hello\"],\n"
    "   \"[UNK]\",\n"
    "   \"[CLS]\",\n"
    "   \"[SEP]\",\n"
    "   \"[PAD]\",\n"
    " )\n"
    " ```\n"
).
-spec word_piece_tokenizer_from_vocab(
    list(binary()),
    binary(),
    binary(),
    binary(),
    binary()
) -> viva_tensor@text@tokenizer:word_piece_tokenizer().
word_piece_tokenizer_from_vocab(
    Vocab,
    Unk_token,
    Cls_token,
    Sep_token,
    Pad_token
) ->
    viva_tensor@text@tokenizer:word_piece_tokenizer_from_vocab(
        Vocab,
        Unk_token,
        Cls_token,
        Sep_token,
        Pad_token
    ).

-file("src/viva_tensor.gleam", 3984).
?DOC(
    " Encode text with a `WordPieceTokenizer`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.word_piece_tokenizer_from_vocab(\n"
    "   [\"[PAD]\", \"[UNK]\", \"[CLS]\", \"[SEP]\", \"hello\"],\n"
    "   \"[UNK]\",\n"
    "   \"[CLS]\",\n"
    "   \"[SEP]\",\n"
    "   \"[PAD]\",\n"
    " )\n"
    " let _ = t.word_piece_encode(tok, \"hello\")\n"
    " ```\n"
).
-spec word_piece_encode(
    viva_tensor@text@tokenizer:word_piece_tokenizer(),
    binary()
) -> list(integer()).
word_piece_encode(Tokenizer, Text) ->
    viva_tensor@text@tokenizer:word_piece_encode(Tokenizer, Text).

-file("src/viva_tensor.gleam", 4006).
?DOC(
    " Decode ids with a `WordPieceTokenizer`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.word_piece_tokenizer_from_vocab(\n"
    "   [\"[PAD]\", \"[UNK]\", \"[CLS]\", \"[SEP]\", \"hello\"],\n"
    "   \"[UNK]\",\n"
    "   \"[CLS]\",\n"
    "   \"[SEP]\",\n"
    "   \"[PAD]\",\n"
    " )\n"
    " let _ = t.word_piece_decode(tok, [2, 4, 3])\n"
    " ```\n"
).
-spec word_piece_decode(
    viva_tensor@text@tokenizer:word_piece_tokenizer(),
    list(integer())
) -> binary().
word_piece_decode(Tokenizer, Ids) ->
    viva_tensor@text@tokenizer:word_piece_decode(Tokenizer, Ids).

-file("src/viva_tensor.gleam", 4025).
?DOC(
    " Build a `BpeTokenizer` from a vocab and pre-trained merges.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.bpe_tokenizer_from_vocab_and_merges(\n"
    "   [\"?\", \"l\", \"o\", \"lo\"],\n"
    "   [#(\"l\", \"o\")],\n"
    "   \"?\",\n"
    " )\n"
    " ```\n"
).
-spec bpe_tokenizer_from_vocab_and_merges(
    list(binary()),
    list({binary(), binary()}),
    binary()
) -> viva_tensor@text@tokenizer:bpe_tokenizer().
bpe_tokenizer_from_vocab_and_merges(Vocab, Merges, Unk_token) ->
    viva_tensor@text@tokenizer:bpe_tokenizer_from_vocab_and_merges(
        Vocab,
        Merges,
        Unk_token
    ).

-file("src/viva_tensor.gleam", 4046).
?DOC(
    " Encode text with a `BpeTokenizer`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.bpe_tokenizer_from_vocab_and_merges(\n"
    "   [\"?\", \"l\", \"o\", \"lo\"],\n"
    "   [#(\"l\", \"o\")],\n"
    "   \"?\",\n"
    " )\n"
    " let _ = t.bpe_encode(tok, \"lo\")\n"
    " ```\n"
).
-spec bpe_encode(viva_tensor@text@tokenizer:bpe_tokenizer(), binary()) -> list(integer()).
bpe_encode(Tokenizer, Text) ->
    viva_tensor@text@tokenizer:bpe_encode(Tokenizer, Text).

-file("src/viva_tensor.gleam", 4063).
?DOC(
    " Decode ids with a `BpeTokenizer`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.bpe_tokenizer_from_vocab_and_merges(\n"
    "   [\"?\", \"l\", \"o\", \"lo\"],\n"
    "   [#(\"l\", \"o\")],\n"
    "   \"?\",\n"
    " )\n"
    " let _ = t.bpe_decode(tok, [3])\n"
    " ```\n"
).
-spec bpe_decode(viva_tensor@text@tokenizer:bpe_tokenizer(), list(integer())) -> binary().
bpe_decode(Tokenizer, Ids) ->
    viva_tensor@text@tokenizer:bpe_decode(Tokenizer, Ids).

-file("src/viva_tensor.gleam", 4096).
?DOC(
    " Build a `UnigramTokenizer` from a list of `(token, log_prob)` pairs.\n"
    " Encoding uses **Viterbi** (max-sum of log-probs), not greedy.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.unigram_tokenizer_from_pieces(\n"
    "   [#(\"<unk>\", -100.0), #(\"<s>\", -100.0), #(\"</s>\", -100.0),\n"
    "    #(\"▁hello\", -1.0)],\n"
    "   \"<unk>\", \"<s>\", \"</s>\",\n"
    " )\n"
    " ```\n"
).
-spec unigram_tokenizer_from_pieces(
    list({binary(), float()}),
    binary(),
    binary(),
    binary()
) -> viva_tensor@text@unigram:unigram_tokenizer().
unigram_tokenizer_from_pieces(Pieces, Unk_token, Bos_token, Eos_token) ->
    viva_tensor@text@unigram:unigram_tokenizer_from_pieces(
        Pieces,
        Unk_token,
        Bos_token,
        Eos_token
    ).

-file("src/viva_tensor.gleam", 4125).
?DOC(
    " Encode `text` into ids using **Viterbi** dynamic programming. Output is\n"
    " `[bos_id, ..pieces, eos_id]`. Pieces falling outside the vocab become\n"
    " `unk_id`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.unigram_tokenizer_from_pieces(\n"
    "   [#(\"<unk>\", -100.0), #(\"<s>\", -100.0), #(\"</s>\", -100.0),\n"
    "    #(\"▁hello\", -1.0)],\n"
    "   \"<unk>\", \"<s>\", \"</s>\",\n"
    " )\n"
    " let _ = t.unigram_encode(tok, \"hello\")\n"
    " ```\n"
).
-spec unigram_encode(viva_tensor@text@unigram:unigram_tokenizer(), binary()) -> list(integer()).
unigram_encode(Tokenizer, Text) ->
    viva_tensor@text@unigram:unigram_encode(Tokenizer, Text).

-file("src/viva_tensor.gleam", 4143).
?DOC(
    " Decode unigram ids back to a string. Strips `bos_id`/`eos_id`, undoes the\n"
    " `▁`-prefix convention, removes a single leading space.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let tok = t.unigram_tokenizer_from_pieces(\n"
    "   [#(\"<unk>\", -100.0), #(\"<s>\", -100.0), #(\"</s>\", -100.0),\n"
    "    #(\"▁hello\", -1.0)],\n"
    "   \"<unk>\", \"<s>\", \"</s>\",\n"
    " )\n"
    " let _ = t.unigram_decode(tok, [1, 3, 2])\n"
    " ```\n"
).
-spec unigram_decode(
    viva_tensor@text@unigram:unigram_tokenizer(),
    list(integer())
) -> binary().
unigram_decode(Tokenizer, Ids) ->
    viva_tensor@text@unigram:unigram_decode(Tokenizer, Ids).

-file("src/viva_tensor.gleam", 4161).
?DOC(
    " Wrap a `UnigramTokenizer` as a `SentencePieceTokenizer`. Encoding goes\n"
    " through Viterbi.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let inner = t.unigram_tokenizer_from_pieces(\n"
    "   [#(\"<unk>\", -100.0), #(\"<s>\", -100.0), #(\"</s>\", -100.0),\n"
    "    #(\"▁hi\", -1.0)],\n"
    "   \"<unk>\", \"<s>\", \"</s>\",\n"
    " )\n"
    " let _ = t.sentence_piece_unigram(inner)\n"
    " ```\n"
).
-spec sentence_piece_unigram(viva_tensor@text@unigram:unigram_tokenizer()) -> viva_tensor@text@unigram:sentence_piece_tokenizer().
sentence_piece_unigram(Unigram) ->
    viva_tensor@text@unigram:sentence_piece_unigram(Unigram).

-file("src/viva_tensor.gleam", 4179).
?DOC(
    " Wrap a `BpeTokenizer` as a `SentencePieceTokenizer`. Encoding uses the\n"
    " greedy merge loop on input renormalized to the `▁`-prefix convention.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let inner = t.bpe_tokenizer_from_vocab_and_merges(\n"
    "   [\"?\", \"▁\", \"h\", \"i\"], [], \"?\",\n"
    " )\n"
    " let _ = t.sentence_piece_bpe(inner)\n"
    " ```\n"
).
-spec sentence_piece_bpe(viva_tensor@text@tokenizer:bpe_tokenizer()) -> viva_tensor@text@unigram:sentence_piece_tokenizer().
sentence_piece_bpe(Bpe) ->
    viva_tensor@text@unigram:sentence_piece_bpe(Bpe).

-file("src/viva_tensor.gleam", 4197).
?DOC(
    " Encode `text` with a `SentencePieceTokenizer`. Dispatches on the\n"
    " wrapper's mode (Viterbi for `SpUnigram`, greedy merges for `SpBpe`).\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let inner = t.unigram_tokenizer_from_pieces(\n"
    "   [#(\"<unk>\", -100.0), #(\"<s>\", -100.0), #(\"</s>\", -100.0),\n"
    "    #(\"▁hi\", -1.0)],\n"
    "   \"<unk>\", \"<s>\", \"</s>\",\n"
    " )\n"
    " let _ = t.sentence_piece_encode(t.sentence_piece_unigram(inner), \"hi\")\n"
    " ```\n"
).
-spec sentence_piece_encode(
    viva_tensor@text@unigram:sentence_piece_tokenizer(),
    binary()
) -> list(integer()).
sentence_piece_encode(Tokenizer, Text) ->
    viva_tensor@text@unigram:sentence_piece_encode(Tokenizer, Text).

-file("src/viva_tensor.gleam", 4218).
?DOC(
    " Decode ids with a `SentencePieceTokenizer`. Reuses the inner Unigram or\n"
    " BPE decoder and unmaps `▁` to ASCII space.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let inner = t.unigram_tokenizer_from_pieces(\n"
    "   [#(\"<unk>\", -100.0), #(\"<s>\", -100.0), #(\"</s>\", -100.0),\n"
    "    #(\"▁hi\", -1.0)],\n"
    "   \"<unk>\", \"<s>\", \"</s>\",\n"
    " )\n"
    " let _ = t.sentence_piece_decode(t.sentence_piece_unigram(inner), [1, 3, 2])\n"
    " ```\n"
).
-spec sentence_piece_decode(
    viva_tensor@text@unigram:sentence_piece_tokenizer(),
    list(integer())
) -> binary().
sentence_piece_decode(Tokenizer, Ids) ->
    viva_tensor@text@unigram:sentence_piece_decode(Tokenizer, Ids).

-file("src/viva_tensor.gleam", 4233).
?DOC(
    " Convert a list of ids into a `[seq_len]` tensor of integer-valued floats.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.ids_to_tensor([1, 2, 3])\n"
    " ```\n"
).
-spec ids_to_tensor(list(integer())) -> viva_tensor@tensor:tensor().
ids_to_tensor(Ids) ->
    viva_tensor@text@tokenizer:ids_to_tensor(Ids).

-file("src/viva_tensor.gleam", 4245).
?DOC(
    " Convert a `[seq_len]` integer-valued tensor back to a `List(Int)`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.tensor_to_ids(t.ids_to_tensor([1, 2, 3]))\n"
    " ```\n"
).
-spec tensor_to_ids(viva_tensor@tensor:tensor()) -> list(integer()).
tensor_to_ids(Tensor) ->
    viva_tensor@text@tokenizer:tensor_to_ids(Tensor).

-file("src/viva_tensor.gleam", 4257).
?DOC(
    " Pad or truncate a list of ids to `max_length` using `pad_id`.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " import viva_tensor as t\n"
    " let _ = t.pad_or_truncate([1, 2], 4, 0)\n"
    " ```\n"
).
-spec pad_or_truncate(list(integer()), integer(), integer()) -> list(integer()).
pad_or_truncate(Ids, Max_length, Pad_id) ->
    viva_tensor@text@tokenizer:pad_or_truncate(Ids, Max_length, Pad_id).

-file("src/viva_tensor.gleam", 4272).
?DOC(" Classification accuracy: `(1/N) * sum_i [pred_i == target_i]`.\n").
-spec accuracy(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        float()} |
    {error, viva_tensor@core@error:tensor_error()}.
accuracy(Predictions, Targets) ->
    viva_tensor@metrics@classification:accuracy(Predictions, Targets).

-file("src/viva_tensor.gleam", 4281).
?DOC(
    " Confusion matrix `[num_classes, num_classes]` where `cm[true, pred]`\n"
    " counts samples.\n"
).
-spec confusion_matrix(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
confusion_matrix(Predictions, Targets, Num_classes) ->
    viva_tensor@metrics@classification:confusion_matrix(
        Predictions,
        Targets,
        Num_classes
    ).

-file("src/viva_tensor.gleam", 4290).
?DOC(" Precision aggregated by the chosen `Average`.\n").
-spec precision(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    viva_tensor@metrics@classification:average()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
precision(Predictions, Targets, Num_classes, Average) ->
    viva_tensor@metrics@classification:precision(
        Predictions,
        Targets,
        Num_classes,
        Average
    ).

-file("src/viva_tensor.gleam", 4300).
?DOC(" Recall aggregated by the chosen `Average`.\n").
-spec recall(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    viva_tensor@metrics@classification:average()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
recall(Predictions, Targets, Num_classes, Average) ->
    viva_tensor@metrics@classification:recall(
        Predictions,
        Targets,
        Num_classes,
        Average
    ).

-file("src/viva_tensor.gleam", 4310).
?DOC(" F1-score aggregated by the chosen `Average`.\n").
-spec f1(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    viva_tensor@metrics@classification:average()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
f1(Predictions, Targets, Num_classes, Average) ->
    viva_tensor@metrics@classification:f1(
        Predictions,
        Targets,
        Num_classes,
        Average
    ).

-file("src/viva_tensor.gleam", 4320).
?DOC(" Top-K accuracy on 2D logits with 1D class-index targets.\n").
-spec top_k_accuracy(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
top_k_accuracy(Logits, Targets, K) ->
    viva_tensor@metrics@classification:top_k_accuracy(Logits, Targets, K).

-file("src/viva_tensor.gleam", 4329).
?DOC(" Per-class intersection-over-union.\n").
-spec iou_per_class(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer()
) -> {ok, list(float())} | {error, viva_tensor@core@error:tensor_error()}.
iou_per_class(Predictions, Targets, Num_classes) ->
    viva_tensor@metrics@classification:iou_per_class(
        Predictions,
        Targets,
        Num_classes
    ).

-file("src/viva_tensor.gleam", 4338).
?DOC(" Mean of per-class IoU.\n").
-spec mean_iou(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
mean_iou(Predictions, Targets, Num_classes) ->
    viva_tensor@metrics@classification:mean_iou(
        Predictions,
        Targets,
        Num_classes
    ).

-file("src/viva_tensor.gleam", 4347).
?DOC(" Mean Absolute Error: `(1/N) * sum_i |pred_i - target_i|`.\n").
-spec mean_absolute_error(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
mean_absolute_error(Predictions, Targets) ->
    viva_tensor@metrics@regression:mean_absolute_error(Predictions, Targets).

-file("src/viva_tensor.gleam", 4355).
?DOC(" Mean Squared Error: `(1/N) * sum_i (pred_i - target_i)^2`.\n").
-spec mean_squared_error(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
mean_squared_error(Predictions, Targets) ->
    viva_tensor@metrics@regression:mean_squared_error(Predictions, Targets).

-file("src/viva_tensor.gleam", 4363).
?DOC(" Root Mean Squared Error: `sqrt(MSE)`.\n").
-spec root_mean_squared_error(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
root_mean_squared_error(Predictions, Targets) ->
    viva_tensor@metrics@regression:root_mean_squared_error(Predictions, Targets).

-file("src/viva_tensor.gleam", 4371).
?DOC(" Coefficient of determination: `1 - SS_res / SS_tot`.\n").
-spec r_squared(viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()) -> {ok,
        float()} |
    {error, viva_tensor@core@error:tensor_error()}.
r_squared(Predictions, Targets) ->
    viva_tensor@metrics@regression:r_squared(Predictions, Targets).

-file("src/viva_tensor.gleam", 4379).
?DOC(" Mean Absolute Percentage Error: `(100/N) * sum_i |pred_i - target_i| / |target_i|`.\n").
-spec mean_absolute_percentage_error(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, float()} | {error, viva_tensor@core@error:tensor_error()}.
mean_absolute_percentage_error(Predictions, Targets) ->
    viva_tensor@metrics@regression:mean_absolute_percentage_error(
        Predictions,
        Targets
    ).

-file("src/viva_tensor.gleam", 4396).
?DOC(
    " `init.zeros` — all-zeros tensor. Same as `zeros`, exposed here for\n"
    " API symmetry with the rest of `init_*`.\n"
).
-spec init_zeros(list(integer())) -> viva_tensor@tensor:tensor().
init_zeros(Shape) ->
    viva_tensor@nn@init:zeros(Shape).

-file("src/viva_tensor.gleam", 4401).
?DOC(" `init.ones` — all-ones tensor. Use case: LayerNorm scale parameters.\n").
-spec init_ones(list(integer())) -> viva_tensor@tensor:tensor().
init_ones(Shape) ->
    viva_tensor@nn@init:ones(Shape).

-file("src/viva_tensor.gleam", 4406).
?DOC(" `init.constant` — constant-filled tensor. Equivalent to `fill`.\n").
-spec init_constant(list(integer()), float()) -> viva_tensor@tensor:tensor().
init_constant(Shape, Value) ->
    viva_tensor@nn@init:constant(Shape, Value).

-file("src/viva_tensor.gleam", 4412).
?DOC(
    " `init.identity` — `[n, n]` identity matrix. Same as `identity`/`eye`,\n"
    " exposed here for API symmetry.\n"
).
-spec init_identity(integer()) -> viva_tensor@tensor:tensor().
init_identity(N) ->
    viva_tensor@nn@init:identity(N).

-file("src/viva_tensor.gleam", 4418).
?DOC(
    " Sample each element uniformly from `[low, high)`.\n"
    " See `viva_tensor/nn/init.uniform`.\n"
).
-spec uniform(list(integer()), float(), float()) -> viva_tensor@tensor:tensor().
uniform(Shape, Low, High) ->
    viva_tensor@nn@init:uniform(Shape, Low, High).

-file("src/viva_tensor.gleam", 4424).
?DOC(
    " Sample each element from `N(mean, std^2)` via the Box-Muller transform.\n"
    " See `viva_tensor/nn/init.normal`.\n"
).
-spec normal(list(integer()), float(), float()) -> viva_tensor@tensor:tensor().
normal(Shape, Mean, Std) ->
    viva_tensor@nn@init:normal(Shape, Mean, Std).

-file("src/viva_tensor.gleam", 4430).
?DOC(
    " Sample each element from `N(mean, std^2)` truncated to `[a, b]`.\n"
    " See `viva_tensor/nn/init.truncated_normal`.\n"
).
-spec truncated_normal(list(integer()), float(), float(), float(), float()) -> viva_tensor@tensor:tensor().
truncated_normal(Shape, Mean, Std, A, B) ->
    viva_tensor@nn@init:truncated_normal(Shape, Mean, Std, A, B).

-file("src/viva_tensor.gleam", 4441).
?DOC(" Glorot uniform init: `U(-a, a)` with `a = sqrt(6 / (fan_in + fan_out))`.\n").
-spec xavier_uniform(integer(), integer()) -> viva_tensor@tensor:tensor().
xavier_uniform(Fan_in, Fan_out) ->
    viva_tensor@nn@init:xavier_uniform(Fan_in, Fan_out).

-file("src/viva_tensor.gleam", 4446).
?DOC(" Glorot normal init: `N(0, std^2)` with `std = sqrt(2 / (fan_in + fan_out))`.\n").
-spec xavier_normal(integer(), integer()) -> viva_tensor@tensor:tensor().
xavier_normal(Fan_in, Fan_out) ->
    viva_tensor@nn@init:xavier_normal(Fan_in, Fan_out).

-file("src/viva_tensor.gleam", 4451).
?DOC(" He uniform init: `U(-bound, bound)` with `bound = gain * sqrt(3 / fan_in)`.\n").
-spec kaiming_uniform(integer(), integer(), float()) -> viva_tensor@tensor:tensor().
kaiming_uniform(Fan_in, Fan_out, Gain) ->
    viva_tensor@nn@init:kaiming_uniform(Fan_in, Fan_out, Gain).

-file("src/viva_tensor.gleam", 4456).
?DOC(" He normal init: `N(0, std^2)` with `std = gain * sqrt(1 / fan_in)`.\n").
-spec kaiming_normal(integer(), integer(), float()) -> viva_tensor@tensor:tensor().
kaiming_normal(Fan_in, Fan_out, Gain) ->
    viva_tensor@nn@init:kaiming_normal(Fan_in, Fan_out, Gain).

-file("src/viva_tensor.gleam", 4462).
?DOC(
    " Orthogonal init via QR. Returns `[rows, cols]` with orthonormal columns\n"
    " (or rows, when `rows < cols`). See `viva_tensor/nn/init.orthogonal`.\n"
).
-spec orthogonal(integer(), integer(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
orthogonal(Rows, Cols, Gain) ->
    viva_tensor@nn@init:orthogonal(Rows, Cols, Gain).

-file("src/viva_tensor.gleam", 4471).
?DOC(" `sqrt(2)` — gain for layers followed by ReLU.\n").
-spec relu_gain() -> float().
relu_gain() ->
    viva_tensor@nn@init:relu_gain().

-file("src/viva_tensor.gleam", 4476).
?DOC(" `sqrt(2 / (1 + slope^2))` — gain for layers followed by Leaky ReLU.\n").
-spec leaky_relu_gain(float()) -> float().
leaky_relu_gain(Negative_slope) ->
    viva_tensor@nn@init:leaky_relu_gain(Negative_slope).

-file("src/viva_tensor.gleam", 4481).
?DOC(" `5/3` — gain for layers followed by tanh.\n").
-spec tanh_gain() -> float().
tanh_gain() ->
    viva_tensor@nn@init:tanh_gain().

-file("src/viva_tensor.gleam", 4486).
?DOC(" `1.0` — gain for layers followed by a linear activation.\n").
-spec linear_gain() -> float().
linear_gain() ->
    viva_tensor@nn@init:linear_gain().

-file("src/viva_tensor.gleam", 4491).
?DOC(" `1.0` — gain for layers followed by sigmoid.\n").
-spec sigmoid_gain() -> float().
sigmoid_gain() ->
    viva_tensor@nn@init:sigmoid_gain().

-file("src/viva_tensor.gleam", 4522).
?DOC(
    " Build a zero-weight `FeedForward` sublayer.\n"
    "\n"
    " Forward: `activation(input @ w1 + b1) @ w2 + b2`.\n"
).
-spec feed_forward_init(
    integer(),
    integer(),
    viva_tensor@nn@transformer:activation()
) -> viva_tensor@nn@transformer:feed_forward().
feed_forward_init(Embed_dim, Hidden_dim, Activation) ->
    viva_tensor@nn@transformer:feed_forward_init(
        Embed_dim,
        Hidden_dim,
        Activation
    ).

-file("src/viva_tensor.gleam", 4531).
?DOC(" Run the FFN forward pass on `[seq_len, embed_dim]`-shaped input.\n").
-spec feed_forward_forward(
    viva_tensor@nn@transformer:feed_forward(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
feed_forward_forward(Ff, Input) ->
    viva_tensor@nn@transformer:feed_forward_forward(Ff, Input).

-file("src/viva_tensor.gleam", 4545).
?DOC(
    " Build a zero-weight pre-norm encoder block.\n"
    "\n"
    " Forward (per block):\n"
    " ```\n"
    " r1     = input + MHA(layer_norm(input), is_causal)\n"
    " output = r1    + FFN(layer_norm(r1))\n"
    " ```\n"
).
-spec encoder_block_init(
    integer(),
    integer(),
    integer(),
    viva_tensor@nn@transformer:activation()
) -> {ok, viva_tensor@nn@transformer:encoder_block()} |
    {error, viva_tensor@core@error:tensor_error()}.
encoder_block_init(Embed_dim, Num_heads, Ffn_hidden_dim, Activation) ->
    viva_tensor@nn@transformer:encoder_block_init(
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim,
        Activation
    ).

-file("src/viva_tensor.gleam", 4560).
?DOC(" Encoder block forward pass on `[seq_len, embed_dim]` input.\n").
-spec encoder_block_forward(
    viva_tensor@nn@transformer:encoder_block(),
    viva_tensor@tensor:tensor(),
    boolean()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
encoder_block_forward(Block, Input, Is_causal) ->
    viva_tensor@nn@transformer:encoder_block_forward(Block, Input, Is_causal).

-file("src/viva_tensor.gleam", 4577).
?DOC(
    " Build a zero-weight pre-norm decoder block (causal self-attn + cross-attn\n"
    " + FFN).\n"
    "\n"
    " Forward (per block):\n"
    " ```\n"
    " r1     = input + MHA_self(layer_norm1(input), is_causal=True)\n"
    " r2     = r1    + MHA_cross(layer_norm2(r1), memory, memory)\n"
    " output = r2    + FFN(layer_norm3(r2))\n"
    " ```\n"
).
-spec decoder_block_init(
    integer(),
    integer(),
    integer(),
    viva_tensor@nn@transformer:activation()
) -> {ok, viva_tensor@nn@transformer:decoder_block()} |
    {error, viva_tensor@core@error:tensor_error()}.
decoder_block_init(Embed_dim, Num_heads, Ffn_hidden_dim, Activation) ->
    viva_tensor@nn@transformer:decoder_block_init(
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim,
        Activation
    ).

-file("src/viva_tensor.gleam", 4593).
?DOC(
    " Decoder block forward pass. Input is `[tgt_seq_len, embed_dim]`,\n"
    " `encoder_output` is `[src_seq_len, embed_dim]`.\n"
).
-spec decoder_block_forward(
    viva_tensor@nn@transformer:decoder_block(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
decoder_block_forward(Block, Input, Encoder_output) ->
    viva_tensor@nn@transformer:decoder_block_forward(
        Block,
        Input,
        Encoder_output
    ).

-file("src/viva_tensor.gleam", 4602).
?DOC(" Build a full encoder+decoder Transformer stack.\n").
-spec transformer_init(
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    viva_tensor@nn@transformer:activation()
) -> {ok, viva_tensor@nn@transformer:transformer()} |
    {error, viva_tensor@core@error:tensor_error()}.
transformer_init(
    Num_encoder_layers,
    Num_decoder_layers,
    Embed_dim,
    Num_heads,
    Ffn_hidden_dim,
    Activation
) ->
    viva_tensor@nn@transformer:transformer_init(
        Num_encoder_layers,
        Num_decoder_layers,
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim,
        Activation
    ).

-file("src/viva_tensor.gleam", 4621).
?DOC(" Run `src` through every encoder block in order.\n").
-spec transformer_encode(
    viva_tensor@nn@transformer:transformer(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
transformer_encode(Model, Src) ->
    viva_tensor@nn@transformer:transformer_encode(Model, Src).

-file("src/viva_tensor.gleam", 4629).
?DOC(" Run `tgt` through every decoder block, attending to `memory` per layer.\n").
-spec transformer_decode(
    viva_tensor@nn@transformer:transformer(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
transformer_decode(Model, Tgt, Memory) ->
    viva_tensor@nn@transformer:transformer_decode(Model, Tgt, Memory).

-file("src/viva_tensor.gleam", 4639).
?DOC(
    " End-to-end forward: `transformer_decode(model, tgt,\n"
    " transformer_encode(model, src))`.\n"
).
-spec transformer_forward(
    viva_tensor@nn@transformer:transformer(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
transformer_forward(Model, Src, Tgt) ->
    viva_tensor@nn@transformer:transformer_forward(Model, Src, Tgt).

-file("src/viva_tensor.gleam", 4665).
?DOC(
    " Resize a CHW (`[C, H, W]`) or NCHW (`[B, C, H, W]`) image to\n"
    " `[..., C, new_h, new_w]` using the requested resampling mode.\n"
).
-spec vision_resize(
    viva_tensor@tensor:tensor(),
    integer(),
    integer(),
    viva_tensor@vision@transforms:resize_mode()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_resize(Image, New_h, New_w, Mode) ->
    viva_tensor@vision@transforms:resize(Image, New_h, New_w, Mode).

-file("src/viva_tensor.gleam", 4675).
?DOC(" Crop the centre `target_h x target_w` region of a CHW/NCHW image.\n").
-spec vision_center_crop(viva_tensor@tensor:tensor(), integer(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_center_crop(Image, Target_h, Target_w) ->
    viva_tensor@vision@transforms:center_crop(Image, Target_h, Target_w).

-file("src/viva_tensor.gleam", 4685).
?DOC(
    " Crop a `target_h x target_w` window at a random top-left corner.\n"
    " Non-deterministic.\n"
).
-spec vision_random_crop(viva_tensor@tensor:tensor(), integer(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_random_crop(Image, Target_h, Target_w) ->
    viva_tensor@vision@transforms:random_crop(Image, Target_h, Target_w).

-file("src/viva_tensor.gleam", 4694).
?DOC(" Mirror the image along the width axis.\n").
-spec vision_horizontal_flip(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_horizontal_flip(Image) ->
    viva_tensor@vision@transforms:horizontal_flip(Image).

-file("src/viva_tensor.gleam", 4699).
?DOC(" Mirror the image along the height axis.\n").
-spec vision_vertical_flip(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_vertical_flip(Image) ->
    viva_tensor@vision@transforms:vertical_flip(Image).

-file("src/viva_tensor.gleam", 4704).
?DOC(" Flip horizontally with probability `p`. Non-deterministic.\n").
-spec vision_random_horizontal_flip(viva_tensor@tensor:tensor(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_random_horizontal_flip(Image, P) ->
    viva_tensor@vision@transforms:random_horizontal_flip(Image, P).

-file("src/viva_tensor.gleam", 4712).
?DOC(" Per-channel `(x - mean[c]) / std[c]` normalization.\n").
-spec vision_normalize(
    viva_tensor@tensor:tensor(),
    list(float()),
    list(float())
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_normalize(Image, Mean, Std) ->
    viva_tensor@vision@transforms:normalize(Image, Mean, Std).

-file("src/viva_tensor.gleam", 4721).
?DOC(" Convert a 3-channel image to grayscale (ITU-R 601 luma).\n").
-spec vision_to_grayscale(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_to_grayscale(Image, Num_output_channels) ->
    viva_tensor@vision@transforms:to_grayscale(Image, Num_output_channels).

-file("src/viva_tensor.gleam", 4729).
?DOC(" Multiply pixel values by `factor`, clamped to `[0, 1]`.\n").
-spec vision_adjust_brightness(viva_tensor@tensor:tensor(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_adjust_brightness(Image, Factor) ->
    viva_tensor@vision@transforms:adjust_brightness(Image, Factor).

-file("src/viva_tensor.gleam", 4738).
?DOC(
    " Linearly interpolate each pixel toward its channel mean and clamp to\n"
    " `[0, 1]`.\n"
).
-spec vision_adjust_contrast(viva_tensor@tensor:tensor(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_adjust_contrast(Image, Factor) ->
    viva_tensor@vision@transforms:adjust_contrast(Image, Factor).

-file("src/viva_tensor.gleam", 4746).
?DOC(" HWC byte image (`[0..255]`) → CHW tensor in `[0, 1]`.\n").
-spec vision_to_tensor(list(integer()), integer(), integer(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_to_tensor(Byte_image, Height, Width, Channels) ->
    viva_tensor@vision@transforms:to_tensor(Byte_image, Height, Width, Channels).

-file("src/viva_tensor.gleam", 4756).
?DOC(" CHW tensor in `[0, 1]` → HWC byte image (`[0..255]`).\n").
-spec vision_to_byte_image(viva_tensor@tensor:tensor()) -> {ok, list(integer())} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_to_byte_image(Image) ->
    viva_tensor@vision@transforms:to_byte_image(Image).

-file("src/viva_tensor.gleam", 4762).
?DOC(
    " Apply a list of transforms in order, threading the result through each\n"
    " step. Bails on the first `Error`.\n"
).
-spec vision_compose(
    list(fun((viva_tensor@tensor:tensor()) -> {ok, viva_tensor@tensor:tensor()} |
        {error, viva_tensor@core@error:tensor_error()})),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
vision_compose(Transforms, Image) ->
    viva_tensor@vision@transforms:compose(Transforms, Image).

-file("src/viva_tensor.gleam", 4782).
?DOC(
    " Read a `.safetensors` file into a `Dict(String, Tensor)`, mapping I/O\n"
    " failures into `HfLoadError.IoError`.\n"
).
-spec load_safetensors_dict(binary()) -> {ok,
        gleam@dict:dict(binary(), viva_tensor@tensor:tensor())} |
    {error, viva_tensor@io@hf_loader:hf_load_error()}.
load_safetensors_dict(Path) ->
    viva_tensor@io@hf_loader:load_safetensors_dict(Path).

-file("src/viva_tensor.gleam", 4790).
?DOC(
    " Load an `Embedding` from `prefix <> \".weight\"` (`[vocab_size,\n"
    " embedding_dim]`).\n"
).
-spec load_embedding(
    gleam@dict:dict(binary(), viva_tensor@tensor:tensor()),
    binary(),
    integer(),
    integer()
) -> {ok, viva_tensor@nn@embedding:embedding()} |
    {error, viva_tensor@io@hf_loader:hf_load_error()}.
load_embedding(Weights, Prefix, Vocab_size, Embedding_dim) ->
    viva_tensor@io@hf_loader:load_embedding(
        Weights,
        Prefix,
        Vocab_size,
        Embedding_dim
    ).

-file("src/viva_tensor.gleam", 4801).
?DOC(
    " Load a `LayerNorm` from `prefix <> \".weight\"` (scale) and\n"
    " `prefix <> \".bias\"`, both `[num_features]`.\n"
).
-spec load_layer_norm(
    gleam@dict:dict(binary(), viva_tensor@tensor:tensor()),
    binary(),
    integer()
) -> {ok, viva_tensor@nn@norm:layer_norm()} |
    {error, viva_tensor@io@hf_loader:hf_load_error()}.
load_layer_norm(Weights, Prefix, Num_features) ->
    viva_tensor@io@hf_loader:load_layer_norm(Weights, Prefix, Num_features).

-file("src/viva_tensor.gleam", 4811).
?DOC(
    " Load a `MultiHeadAttention` from `q_proj`/`k_proj`/`v_proj`/`out_proj`\n"
    " (weight + bias each) under the supplied `prefix`.\n"
).
-spec load_multi_head_attention(
    gleam@dict:dict(binary(), viva_tensor@tensor:tensor()),
    binary(),
    integer(),
    integer()
) -> {ok, viva_tensor@nn@attention:multi_head_attention()} |
    {error, viva_tensor@io@hf_loader:hf_load_error()}.
load_multi_head_attention(Weights, Prefix, Num_heads, Embed_dim) ->
    viva_tensor@io@hf_loader:load_multi_head_attention(
        Weights,
        Prefix,
        Num_heads,
        Embed_dim
    ).

-file("src/viva_tensor.gleam", 4822).
?DOC(
    " Load a `FeedForward` from `linear1`/`linear2` (weight + bias each) under\n"
    " the supplied `prefix`.\n"
).
-spec load_feed_forward(
    gleam@dict:dict(binary(), viva_tensor@tensor:tensor()),
    binary(),
    integer(),
    integer(),
    viva_tensor@nn@transformer:activation()
) -> {ok, viva_tensor@nn@transformer:feed_forward()} |
    {error, viva_tensor@io@hf_loader:hf_load_error()}.
load_feed_forward(Weights, Prefix, Embed_dim, Hidden_dim, Activation) ->
    viva_tensor@io@hf_loader:load_feed_forward(
        Weights,
        Prefix,
        Embed_dim,
        Hidden_dim,
        Activation
    ).

-file("src/viva_tensor.gleam", 4840).
?DOC(
    " Load a single `EncoderBlock` (MHA + 2× LayerNorm + FFN) under\n"
    " `prefix` (e.g. `\"encoder.layers.0\"`).\n"
).
-spec load_encoder_block(
    gleam@dict:dict(binary(), viva_tensor@tensor:tensor()),
    binary(),
    integer(),
    integer(),
    integer(),
    viva_tensor@nn@transformer:activation()
) -> {ok, viva_tensor@nn@transformer:encoder_block()} |
    {error, viva_tensor@io@hf_loader:hf_load_error()}.
load_encoder_block(
    Weights,
    Prefix,
    Num_heads,
    Embed_dim,
    Hidden_dim,
    Activation
) ->
    viva_tensor@io@hf_loader:load_encoder_block(
        Weights,
        Prefix,
        Num_heads,
        Embed_dim,
        Hidden_dim,
        Activation
    ).

-file("src/viva_tensor.gleam", 4860).
?DOC(
    " Load a full `Transformer` (encoder stack + decoder stack) under the\n"
    " conventional `encoder.layers.{i}` / `decoder.layers.{i}` prefixes.\n"
).
-spec load_transformer(
    gleam@dict:dict(binary(), viva_tensor@tensor:tensor()),
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    viva_tensor@nn@transformer:activation()
) -> {ok, viva_tensor@nn@transformer:transformer()} |
    {error, viva_tensor@io@hf_loader:hf_load_error()}.
load_transformer(
    Weights,
    Num_enc_layers,
    Num_dec_layers,
    Embed_dim,
    Num_heads,
    Hidden_dim,
    Activation
) ->
    viva_tensor@io@hf_loader:load_transformer(
        Weights,
        Num_enc_layers,
        Num_dec_layers,
        Embed_dim,
        Num_heads,
        Hidden_dim,
        Activation
    ).

-file("src/viva_tensor.gleam", 4882).
?DOC(
    " Read a `.safetensors` file then project it into a `Transformer` using\n"
    " the dimensions in `config`.\n"
).
-spec from_safetensors_file(
    binary(),
    viva_tensor@io@hf_loader:transformer_config()
) -> {ok, viva_tensor@nn@transformer:transformer()} |
    {error, viva_tensor@io@hf_loader:hf_load_error()}.
from_safetensors_file(Path, Config) ->
    viva_tensor@io@hf_loader:from_safetensors_file(Path, Config).

-file("src/viva_tensor.gleam", 4897).
?DOC(" Build a `ColorJitterConfig` (brightness/contrast/saturation/hue strengths).\n").
-spec color_jitter_init(float(), float(), float(), float()) -> viva_tensor@vision@augmentations:color_jitter_config().
color_jitter_init(Brightness, Contrast, Saturation, Hue) ->
    viva_tensor@vision@augmentations:color_jitter_init(
        Brightness,
        Contrast,
        Saturation,
        Hue
    ).

-file("src/viva_tensor.gleam", 4908).
?DOC(
    " Apply randomized brightness/contrast/saturation/hue to `[C, H, W]` or\n"
    " `[B, C, H, W]` RGB images.\n"
).
-spec color_jitter_forward(
    viva_tensor@vision@augmentations:color_jitter_config(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
color_jitter_forward(Config, Image) ->
    viva_tensor@vision@augmentations:color_jitter_forward(Config, Image).

-file("src/viva_tensor.gleam", 4917).
?DOC(
    " MixUp on a batch — convex combination of images + soft labels with mixing\n"
    " ratio drawn from `Beta(alpha, alpha)`.\n"
).
-spec mixup(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    float()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
mixup(Images, Labels, Num_classes, Alpha) ->
    viva_tensor@vision@augmentations:mixup(Images, Labels, Num_classes, Alpha).

-file("src/viva_tensor.gleam", 4928).
?DOC(
    " CutMix on a batch — paste a random rectangle from a partner image, label\n"
    " mixing reflects the actual pasted area.\n"
).
-spec cutmix(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    float()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
cutmix(Images, Labels, Num_classes, Alpha) ->
    viva_tensor@vision@augmentations:cutmix(Images, Labels, Num_classes, Alpha).

-file("src/viva_tensor.gleam", 4952).
?DOC(" Precompute the schedule tables for either a linear or cosine `NoiseSchedule`.\n").
-spec build_schedule(viva_tensor@diffusion@samplers:noise_schedule()) -> viva_tensor@diffusion@samplers:scheduler_state().
build_schedule(Schedule) ->
    viva_tensor@diffusion@samplers:build_schedule(Schedule).

-file("src/viva_tensor.gleam", 4957).
?DOC(" One DDPM reverse step at index `t`.\n").
-spec ddpm_step(
    viva_tensor@diffusion@samplers:scheduler_state(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
ddpm_step(State, X_t, Model_pred, T) ->
    viva_tensor@diffusion@samplers:ddpm_step(State, X_t, Model_pred, T).

-file("src/viva_tensor.gleam", 4967).
?DOC(" One DDIM reverse step at index `t`. `eta=0` is deterministic.\n").
-spec ddim_step(
    viva_tensor@diffusion@samplers:scheduler_state(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer(),
    float()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
ddim_step(State, X_t, Model_pred, T, Eta) ->
    viva_tensor@diffusion@samplers:ddim_step(State, X_t, Model_pred, T, Eta).

-file("src/viva_tensor.gleam", 4978).
?DOC(" Full reverse sampling loop. Calls `model_fn` at each step.\n").
-spec sample(
    viva_tensor@diffusion@samplers:sampler_config(),
    viva_tensor@diffusion@samplers:scheduler_state(),
    list(integer()),
    fun((viva_tensor@tensor:tensor(), integer()) -> {ok,
            viva_tensor@tensor:tensor()} |
        {error, viva_tensor@core@error:tensor_error()})
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
sample(Config, State, Shape, Model_fn) ->
    viva_tensor@diffusion@samplers:sample(Config, State, Shape, Model_fn).

-file("src/viva_tensor.gleam", 4997).
?DOC(" Traced ReLU forward + backward (saves INPUT in closure).\n").
-spec traced_relu(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_relu(Tape, X) ->
    viva_tensor@nn@autograd:traced_relu(Tape, X).

-file("src/viva_tensor.gleam", 5005).
?DOC(" Traced sigmoid forward + backward (saves OUTPUT in closure).\n").
-spec traced_sigmoid(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_sigmoid(Tape, X) ->
    viva_tensor@nn@autograd:traced_sigmoid(Tape, X).

-file("src/viva_tensor.gleam", 5013).
?DOC(" Traced tanh forward + backward (saves OUTPUT in closure).\n").
-spec traced_tanh(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_tanh(Tape, X) ->
    viva_tensor@nn@autograd:traced_tanh(Tape, X).

-file("src/viva_tensor.gleam", 5021).
?DOC(" Traced GELU (exact) forward + backward (saves INPUT in closure).\n").
-spec traced_gelu(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_gelu(Tape, X) ->
    viva_tensor@nn@autograd:traced_gelu(Tape, X).

-file("src/viva_tensor.gleam", 5029).
?DOC(" Traced softmax along `axis` (saves OUTPUT in closure).\n").
-spec traced_softmax(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    integer()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_softmax(Tape, X, Axis) ->
    viva_tensor@nn@autograd:traced_softmax(Tape, X, Axis).

-file("src/viva_tensor.gleam", 5038).
?DOC(" Traced matmul (saves both INPUT operands in closure).\n").
-spec traced_matmul(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_matmul(Tape, A, B) ->
    viva_tensor@nn@autograd:traced_matmul(Tape, A, B).

-file("src/viva_tensor.gleam", 5047).
?DOC(" Traced linear `y = x @ w` (saves INPUTS in closure).\n").
-spec traced_linear(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_linear(Tape, X, W) ->
    viva_tensor@nn@autograd:traced_linear(Tape, X, W).

-file("src/viva_tensor.gleam", 5056).
?DOC(" Traced add (saves INPUT shapes for broadcast reduction).\n").
-spec traced_add(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_add(Tape, A, B) ->
    viva_tensor@nn@autograd:traced_add(Tape, A, B).

-file("src/viva_tensor.gleam", 5065).
?DOC(" Traced sub (saves INPUT shapes for broadcast reduction).\n").
-spec traced_sub(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_sub(Tape, A, B) ->
    viva_tensor@nn@autograd:traced_sub(Tape, A, B).

-file("src/viva_tensor.gleam", 5074).
?DOC(" Traced elementwise mul (saves INPUT operands).\n").
-spec traced_mul(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@nn@autograd:variable()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_mul(Tape, A, B) ->
    viva_tensor@nn@autograd:traced_mul(Tape, A, B).

-file("src/viva_tensor.gleam", 5083).
?DOC(" Traced scale-by-constant (saves only the float scalar).\n").
-spec traced_scale(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    float()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_scale(Tape, X, Scalar) ->
    viva_tensor@nn@autograd:traced_scale(Tape, X, Scalar).

-file("src/viva_tensor.gleam", 5092).
?DOC(" Traced LayerNorm over last axis (saves FORWARD STATS: x_hat + rstds).\n").
-spec traced_layer_norm(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@nn@autograd:variable(),
    float()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_layer_norm(Tape, X, Scale, Bias, Eps) ->
    viva_tensor@nn@autograd:traced_layer_norm(Tape, X, Scale, Bias, Eps).

-file("src/viva_tensor.gleam", 5103).
?DOC(" Traced MSE loss (target is constant; saves pred-target diff in closure).\n").
-spec traced_mse_loss(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@core@tensor:tensor()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_mse_loss(Tape, Pred, Target) ->
    viva_tensor@nn@autograd:traced_mse_loss(Tape, Pred, Target).

-file("src/viva_tensor.gleam", 5112).
?DOC(" Traced L1 loss (target is constant; saves pred-target diff in closure).\n").
-spec traced_l1_loss(
    viva_tensor@nn@autograd:tape(),
    viva_tensor@nn@autograd:variable(),
    viva_tensor@core@tensor:tensor()
) -> {ok, viva_tensor@nn@autograd:traced(viva_tensor@nn@autograd:variable())} |
    {error, viva_tensor@core@error:tensor_error()}.
traced_l1_loss(Tape, Pred, Target) ->
    viva_tensor@nn@autograd:traced_l1_loss(Tape, Pred, Target).

-file("src/viva_tensor.gleam", 5131).
?DOC(" Build a `Router` with a zero-filled gate `[embed_dim, num_experts]`.\n").
-spec router_init(integer(), integer(), integer()) -> viva_tensor@nn@moe:router().
router_init(Embed_dim, Num_experts, Top_k) ->
    viva_tensor@nn@moe:router_init(Embed_dim, Num_experts, Top_k).

-file("src/viva_tensor.gleam", 5137).
?DOC(
    " Route `[tokens, embed_dim]` through the gate, returning\n"
    " `#(expert_ids, expert_weights, aux_loss)`.\n"
).
-spec router_route(viva_tensor@nn@moe:router(), viva_tensor@tensor:tensor()) -> {ok,
        {viva_tensor@tensor:tensor(),
            viva_tensor@tensor:tensor(),
            viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
router_route(Router, Tokens) ->
    viva_tensor@nn@moe:router_route(Router, Tokens).

-file("src/viva_tensor.gleam", 5145).
?DOC(" Build a `MoeBlock` with zero-weight experts and a fresh router.\n").
-spec moe_block_init(integer(), integer(), integer(), integer()) -> {ok,
        viva_tensor@nn@moe:moe_block()} |
    {error, viva_tensor@core@error:tensor_error()}.
moe_block_init(Embed_dim, Hidden_dim, Num_experts, Top_k) ->
    viva_tensor@nn@moe:moe_block_init(Embed_dim, Hidden_dim, Num_experts, Top_k).

-file("src/viva_tensor.gleam", 5155).
?DOC(" Run the MoE block forward pass on `[tokens, embed_dim]` input.\n").
-spec moe_block_forward(
    viva_tensor@nn@moe:moe_block(),
    viva_tensor@tensor:tensor()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
moe_block_forward(Block, Tokens) ->
    viva_tensor@nn@moe:moe_block_forward(Block, Tokens).

-file("src/viva_tensor.gleam", 5163).
?DOC(" Switch Transformer load-balancing auxiliary loss.\n").
-spec compute_load_balance_loss(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
compute_load_balance_loss(Router_probs, Expert_assignments, Num_experts) ->
    viva_tensor@nn@moe:compute_load_balance_loss(
        Router_probs,
        Expert_assignments,
        Num_experts
    ).

-file("src/viva_tensor.gleam", 5177).
?DOC(
    " Per-expert importance (sum of router probs) and load (count of top-k\n"
    " assignments). See `viva_tensor/nn/moe.expert_distribution`.\n"
).
-spec expert_distribution(
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor(),
    integer()
) -> {ok, {viva_tensor@tensor:tensor(), viva_tensor@tensor:tensor()}} |
    {error, viva_tensor@core@error:tensor_error()}.
expert_distribution(Router_probs, Expert_assignments, Num_experts) ->
    viva_tensor@nn@moe:expert_distribution(
        Router_probs,
        Expert_assignments,
        Num_experts
    ).

-file("src/viva_tensor.gleam", 5198).
?DOC(" Build a zero-weight `LlamaBlock`.\n").
-spec llama_block_init(integer(), integer(), integer()) -> {ok,
        viva_tensor@models@llama:llama_block()} |
    {error, viva_tensor@core@error:tensor_error()}.
llama_block_init(Embed_dim, Num_heads, Ffn_hidden_dim) ->
    viva_tensor@models@llama:llama_block_init(
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim
    ).

-file("src/viva_tensor.gleam", 5207).
?DOC(" Run a `LlamaBlock` on `[seq_len, embed_dim]` input.\n").
-spec llama_block_forward(
    viva_tensor@models@llama:llama_block(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
llama_block_forward(Block, Input) ->
    viva_tensor@models@llama:llama_block_forward(Block, Input).

-file("src/viva_tensor.gleam", 5215).
?DOC(" Build a zero-weight `LlamaModel` with `num_layers` blocks.\n").
-spec llama_model_init(integer(), integer(), integer(), integer(), integer()) -> {ok,
        viva_tensor@models@llama:llama_model()} |
    {error, viva_tensor@core@error:tensor_error()}.
llama_model_init(Num_layers, Vocab_size, Embed_dim, Num_heads, Ffn_hidden_dim) ->
    viva_tensor@models@llama:llama_model_init(
        Num_layers,
        Vocab_size,
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim
    ).

-file("src/viva_tensor.gleam", 5232).
?DOC(" End-to-end Llama forward: 1D `token_ids` -> logits `[seq, vocab]`.\n").
-spec llama_model_forward(
    viva_tensor@models@llama:llama_model(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
llama_model_forward(Model, Token_ids) ->
    viva_tensor@models@llama:llama_model_forward(Model, Token_ids).

-file("src/viva_tensor.gleam", 5253).
?DOC(" Build a zero-weight `BertEmbedding`.\n").
-spec bert_embedding_init(integer(), integer(), integer(), integer()) -> viva_tensor@models@bert:bert_embedding().
bert_embedding_init(Vocab_size, Embed_dim, Max_position, Num_token_types) ->
    viva_tensor@models@bert:bert_embedding_init(
        Vocab_size,
        Embed_dim,
        Max_position,
        Num_token_types
    ).

-file("src/viva_tensor.gleam", 5268).
?DOC(" Run the BERT embedding layer.\n").
-spec bert_embedding_forward(
    viva_tensor@models@bert:bert_embedding(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
bert_embedding_forward(Layer, Token_ids, Token_type_ids) ->
    viva_tensor@models@bert:bert_embedding_forward(
        Layer,
        Token_ids,
        Token_type_ids
    ).

-file("src/viva_tensor.gleam", 5277).
?DOC(" Build a zero-weight `BertBlock`.\n").
-spec bert_block_init(integer(), integer(), integer()) -> {ok,
        viva_tensor@models@bert:bert_block()} |
    {error, viva_tensor@core@error:tensor_error()}.
bert_block_init(Embed_dim, Num_heads, Ffn_hidden_dim) ->
    viva_tensor@models@bert:bert_block_init(
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim
    ).

-file("src/viva_tensor.gleam", 5286).
?DOC(" Run a `BertBlock` on `[seq_len, embed_dim]` input.\n").
-spec bert_block_forward(
    viva_tensor@models@bert:bert_block(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
bert_block_forward(Block, Input) ->
    viva_tensor@models@bert:bert_block_forward(Block, Input).

-file("src/viva_tensor.gleam", 5294).
?DOC(" Build a zero-weight `BertModel` with `num_layers` blocks.\n").
-spec bert_model_init(
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, viva_tensor@models@bert:bert_model()} |
    {error, viva_tensor@core@error:tensor_error()}.
bert_model_init(
    Num_layers,
    Vocab_size,
    Embed_dim,
    Num_heads,
    Ffn_hidden_dim,
    Max_position
) ->
    viva_tensor@models@bert:bert_model_init(
        Num_layers,
        Vocab_size,
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim,
        Max_position
    ).

-file("src/viva_tensor.gleam", 5313).
?DOC(" End-to-end BERT forward: `token_ids`, `token_type_ids` -> hidden states.\n").
-spec bert_model_forward(
    viva_tensor@models@bert:bert_model(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
bert_model_forward(Model, Token_ids, Token_type_ids) ->
    viva_tensor@models@bert:bert_model_forward(Model, Token_ids, Token_type_ids).

-file("src/viva_tensor.gleam", 5331).
?DOC(" Build a zero-weight `GptBlock`.\n").
-spec gpt_block_init(integer(), integer(), integer()) -> {ok,
        viva_tensor@models@gpt:gpt_block()} |
    {error, viva_tensor@core@error:tensor_error()}.
gpt_block_init(Embed_dim, Num_heads, Ffn_hidden_dim) ->
    viva_tensor@models@gpt:gpt_block_init(Embed_dim, Num_heads, Ffn_hidden_dim).

-file("src/viva_tensor.gleam", 5340).
?DOC(" Run a `GptBlock` on `[seq_len, embed_dim]` input.\n").
-spec gpt_block_forward(
    viva_tensor@models@gpt:gpt_block(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
gpt_block_forward(Block, Input) ->
    viva_tensor@models@gpt:gpt_block_forward(Block, Input).

-file("src/viva_tensor.gleam", 5348).
?DOC(" Build a zero-weight `GptModel`.\n").
-spec gpt_model_init(
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, viva_tensor@models@gpt:gpt_model()} |
    {error, viva_tensor@core@error:tensor_error()}.
gpt_model_init(
    Num_layers,
    Vocab_size,
    Embed_dim,
    Num_heads,
    Ffn_hidden_dim,
    Max_position
) ->
    viva_tensor@models@gpt:gpt_model_init(
        Num_layers,
        Vocab_size,
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim,
        Max_position
    ).

-file("src/viva_tensor.gleam", 5367).
?DOC(" End-to-end GPT forward: 1D `token_ids` -> logits `[seq, vocab]`.\n").
-spec gpt_model_forward(
    viva_tensor@models@gpt:gpt_model(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
gpt_model_forward(Model, Token_ids) ->
    viva_tensor@models@gpt:gpt_model_forward(Model, Token_ids).

-file("src/viva_tensor.gleam", 5384).
?DOC(" Build a zero-weight T5 encoder block.\n").
-spec t5_encoder_block_init(integer(), integer(), integer()) -> {ok,
        viva_tensor@models@t5:t5_block()} |
    {error, viva_tensor@core@error:tensor_error()}.
t5_encoder_block_init(Embed_dim, Num_heads, Ffn_hidden_dim) ->
    viva_tensor@models@t5:t5_encoder_block_init(
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim
    ).

-file("src/viva_tensor.gleam", 5393).
?DOC(" Build a zero-weight T5 decoder block (causal self-attn + cross-attn).\n").
-spec t5_decoder_block_init(integer(), integer(), integer()) -> {ok,
        viva_tensor@models@t5:t5_block()} |
    {error, viva_tensor@core@error:tensor_error()}.
t5_decoder_block_init(Embed_dim, Num_heads, Ffn_hidden_dim) ->
    viva_tensor@models@t5:t5_decoder_block_init(
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim
    ).

-file("src/viva_tensor.gleam", 5402).
?DOC(" Run a T5 encoder block on `[seq_len, embed_dim]` input.\n").
-spec t5_encoder_block_forward(
    viva_tensor@models@t5:t5_block(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
t5_encoder_block_forward(Block, Input) ->
    viva_tensor@models@t5:t5_encoder_block_forward(Block, Input).

-file("src/viva_tensor.gleam", 5411).
?DOC(
    " Run a T5 decoder block on `[seq_len, embed_dim]` input attending to\n"
    " `memory` (encoder output).\n"
).
-spec t5_decoder_block_forward(
    viva_tensor@models@t5:t5_block(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
t5_decoder_block_forward(Block, Input, Memory) ->
    viva_tensor@models@t5:t5_decoder_block_forward(Block, Input, Memory).

-file("src/viva_tensor.gleam", 5420).
?DOC(" Build a zero-weight T5 model with `num_encoder_layers` + `num_decoder_layers`.\n").
-spec t5_model_init(
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> {ok, viva_tensor@models@t5:t5_model()} |
    {error, viva_tensor@core@error:tensor_error()}.
t5_model_init(
    Num_encoder_layers,
    Num_decoder_layers,
    Vocab_size,
    Embed_dim,
    Num_heads,
    Ffn_hidden_dim
) ->
    viva_tensor@models@t5:t5_model_init(
        Num_encoder_layers,
        Num_decoder_layers,
        Vocab_size,
        Embed_dim,
        Num_heads,
        Ffn_hidden_dim
    ).

-file("src/viva_tensor.gleam", 5439).
?DOC(" End-to-end T5 forward: `src_token_ids` + `tgt_token_ids` -> logits.\n").
-spec t5_model_forward(
    viva_tensor@models@t5:t5_model(),
    viva_tensor@tensor:tensor(),
    viva_tensor@tensor:tensor()
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
t5_model_forward(Model, Src_token_ids, Tgt_token_ids) ->
    viva_tensor@models@t5:t5_model_forward(Model, Src_token_ids, Tgt_token_ids).

-file("src/viva_tensor.gleam", 5470).
?DOC(
    " Aggregate per-worker gradient lists synchronously. See\n"
    " `viva_tensor/distributed/trainer.distribute_grads`.\n"
).
-spec distribute_grads(
    list(list(viva_tensor@nn@optim:grad_pair())),
    viva_tensor@distributed@trainer:grad_aggregation()
) -> {ok, list(viva_tensor@nn@optim:grad_pair())} |
    {error, viva_tensor@core@error:tensor_error()}.
distribute_grads(Per_worker_grads, Aggregation) ->
    viva_tensor@distributed@trainer:distribute_grads(
        Per_worker_grads,
        Aggregation
    ).

-file("src/viva_tensor.gleam", 5479).
?DOC(
    " Apply one synchronous data-parallel optimizer step. See\n"
    " `viva_tensor/distributed/trainer.synchronous_train_step`.\n"
).
-spec synchronous_train_step(
    viva_tensor@nn@optim:optimizer(),
    list(viva_tensor@nn@optim:param()),
    list(list(viva_tensor@nn@optim:grad_pair())),
    viva_tensor@distributed@trainer:grad_aggregation()
) -> {ok,
        {viva_tensor@nn@optim:optimizer(), list(viva_tensor@nn@optim:param())}} |
    {error, viva_tensor@core@error:tensor_error()}.
synchronous_train_step(Opt, Params, Per_worker_grads, Aggregation) ->
    viva_tensor@distributed@trainer:synchronous_train_step(
        Opt,
        Params,
        Per_worker_grads,
        Aggregation
    ).

-file("src/viva_tensor.gleam", 5495).
?DOC(
    " Run synchronous data-parallel SGD. See\n"
    " `viva_tensor/distributed/trainer.train_synchronous`.\n"
).
-spec train_synchronous(
    viva_tensor@distributed@trainer:train_config(),
    list(viva_tensor@nn@optim:param()),
    viva_tensor@nn@optim:optimizer(),
    viva_tensor@data@dataloader:data_loader(),
    fun((viva_tensor@data@dataloader:batch(), list(viva_tensor@nn@optim:param())) -> {ok,
            list(viva_tensor@nn@optim:grad_pair())} |
        {error, viva_tensor@core@error:tensor_error()}),
    integer()
) -> {ok, viva_tensor@distributed@trainer:train_result()} |
    {error, viva_tensor@core@error:tensor_error()}.
train_synchronous(
    Config,
    Initial_params,
    Initial_optimizer,
    Data_loader,
    Compute_grads,
    Num_steps
) ->
    viva_tensor@distributed@trainer:train_synchronous(
        Config,
        Initial_params,
        Initial_optimizer,
        Data_loader,
        Compute_grads,
        Num_steps
    ).

-file("src/viva_tensor.gleam", 5532).
?DOC(" Greedy argmax over a 1-D logits tensor.\n").
-spec greedy_sample(viva_tensor@tensor:tensor()) -> {ok, integer()} |
    {error, viva_tensor@core@error:tensor_error()}.
greedy_sample(Logits) ->
    viva_tensor@generate@speculative:greedy_sample(Logits).

-file("src/viva_tensor.gleam", 5540).
?DOC(
    " Temperature + top-k + top-p sample from a 1-D logits tensor.\n"
    "\n"
    " Named `sample_token` to avoid colliding with `viva_tensor.sample` from\n"
    " the diffusion samplers re-export.\n"
).
-spec sample_token(
    viva_tensor@tensor:tensor(),
    viva_tensor@generate@speculative:sampling_config()
) -> {ok, integer()} | {error, viva_tensor@core@error:tensor_error()}.
sample_token(Logits, Config) ->
    viva_tensor@generate@speculative:sample(Logits, Config).

-file("src/viva_tensor.gleam", 5548).
?DOC(" Divide every logit by `temperature` (no-op for `1.0`, defensive for `0.0`).\n").
-spec apply_temperature(viva_tensor@tensor:tensor(), float()) -> viva_tensor@tensor:tensor().
apply_temperature(Logits, Temperature) ->
    viva_tensor@generate@speculative:apply_temperature(Logits, Temperature).

-file("src/viva_tensor.gleam", 5553).
?DOC(" Mask logits outside the top-`k` (set to large negative sentinel).\n").
-spec top_k_filter(viva_tensor@tensor:tensor(), integer()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
top_k_filter(Logits, K) ->
    viva_tensor@generate@speculative:top_k_filter(Logits, K).

-file("src/viva_tensor.gleam", 5558).
?DOC(" Nucleus (top-p) filter — mask the smallest-prob tail until cum > p.\n").
-spec top_p_filter(viva_tensor@tensor:tensor(), float()) -> {ok,
        viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
top_p_filter(Logits, P) ->
    viva_tensor@generate@speculative:top_p_filter(Logits, P).

-file("src/viva_tensor.gleam", 5563).
?DOC(" Speculative decoding (Chen 2023 / Leviathan 2023).\n").
-spec speculative_decode(
    viva_tensor@generate@speculative:speculative_config(),
    list(integer()),
    fun((list(integer())) -> {ok, viva_tensor@tensor:tensor()} |
        {error, viva_tensor@core@error:tensor_error()}),
    fun((list(integer())) -> {ok, viva_tensor@tensor:tensor()} |
        {error, viva_tensor@core@error:tensor_error()})
) -> {ok, list(integer())} | {error, viva_tensor@core@error:tensor_error()}.
speculative_decode(Config, Initial_tokens, Draft_fn, Verify_fn) ->
    viva_tensor@generate@speculative:speculative_decode(
        Config,
        Initial_tokens,
        Draft_fn,
        Verify_fn
    ).

-file("src/viva_tensor.gleam", 5578).
?DOC(" Autoregressive greedy generation with optional stop token.\n").
-spec greedy_generate(
    list(integer()),
    integer(),
    fun((list(integer())) -> {ok, viva_tensor@tensor:tensor()} |
        {error, viva_tensor@core@error:tensor_error()}),
    gleam@option:option(integer())
) -> {ok, list(integer())} | {error, viva_tensor@core@error:tensor_error()}.
greedy_generate(Initial_tokens, Max_new_tokens, Model_fn, Stop_token) ->
    viva_tensor@generate@speculative:greedy_generate(
        Initial_tokens,
        Max_new_tokens,
        Model_fn,
        Stop_token
    ).

-file("src/viva_tensor.gleam", 5596).
?DOC(
    " Load a Llama-family HuggingFace SafeTensors model into an opaque handle.\n"
    "\n"
    " This caches the tokenizer, embedding table, blocked FP8 layer weights,\n"
    " final RMSNorm, `lm_head`, and RoPE frequencies for repeated generation.\n"
).
-spec load_model(binary()) -> {ok, model_handle()} | {error, binary()}.
load_model(Path) ->
    viva_tensor_llm:load_for_gleam(Path).

-file("src/viva_tensor.gleam", 5604).
?DOC(
    " Generate text from a loaded model handle.\n"
    "\n"
    " `temperature == 0.0` uses the fused argmax decode-step path. Non-zero\n"
    " sampling is intentionally left for the next sampling-focused API pass.\n"
).
-spec generate(model_handle(), binary(), generate_opts()) -> {ok, generation()} |
    {error, binary()}.
generate(Handle, Prompt, Opts) ->
    Top_k = case erlang:element(4, Opts) of
        top_k_infinity ->
            -1;

        {top_k, K} ->
            K
    end,
    case viva_tensor_llm:generate_for_gleam(
        Handle,
        Prompt,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        Top_k,
        erlang:element(5, Opts),
        erlang:element(6, Opts),
        erlang:element(7, Opts)
    ) of
        {ok, {Tokens, Text, Ms_per_token, Total_tokens}} ->
            {ok, {generation, Tokens, Text, Ms_per_token, Total_tokens}};

        {error, Reason} ->
            {error, Reason}
    end.

-file("src/viva_tensor.gleam", 5638).
?DOC(" Default deterministic argmax generation options.\n").
-spec default_generate_opts() -> generate_opts().
default_generate_opts() ->
    {generate_opts, 50, +0.0, top_k_infinity, 1.0, 42, true}.

-file("src/viva_tensor.gleam", 5669).
?DOC(" Quantize + lay out a dense weight for the CUTLASS FP8 GEMM path.\n").
-spec prepack_fp8_weight(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@native@inference:packed_weight_fp8()} |
    {error, viva_tensor@core@error:tensor_error()}.
prepack_fp8_weight(Weight) ->
    viva_tensor@native@inference:prepack_fp8_weight(Weight).

-file("src/viva_tensor.gleam", 5676).
?DOC(" Quantize + 2:4-prune a weight into the INT8 sparse layout.\n").
-spec prepack_int8_sparse_24_weight(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@native@inference:packed_weight_int8_sparse()} |
    {error, viva_tensor@core@error:tensor_error()}.
prepack_int8_sparse_24_weight(Weight) ->
    viva_tensor@native@inference:prepack_int8_sparse_24_weight(Weight).

-file("src/viva_tensor.gleam", 5684).
?DOC(
    " Quantize + 2:4-prune a weight into the INT4 sparse layout (the\n"
    " highest-TFLOPS inference path on Ada SM89).\n"
).
-spec prepack_int4_sparse_24_weight(viva_tensor@tensor:tensor()) -> {ok,
        viva_tensor@native@inference:packed_weight_int4_sparse()} |
    {error, viva_tensor@core@error:tensor_error()}.
prepack_int4_sparse_24_weight(Weight) ->
    viva_tensor@native@inference:prepack_int4_sparse_24_weight(Weight).

-file("src/viva_tensor.gleam", 5691).
?DOC(" FP8 linear: `input @ weight + bias?`.\n").
-spec linear_fp8(
    viva_tensor@tensor:tensor(),
    viva_tensor@native@inference:packed_weight_fp8(),
    gleam@option:option(viva_tensor@tensor:tensor())
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_fp8(Input, Weight, Bias) ->
    viva_tensor@native@inference:linear_fp8(Input, Weight, Bias).

-file("src/viva_tensor.gleam", 5700).
?DOC(" INT4 2:4 sparse linear: `input @ weight + bias?`.\n").
-spec linear_int4_sparse(
    viva_tensor@tensor:tensor(),
    viva_tensor@native@inference:packed_weight_int4_sparse(),
    gleam@option:option(viva_tensor@tensor:tensor())
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_int4_sparse(Input, Weight, Bias) ->
    viva_tensor@native@inference:linear_int4_sparse(Input, Weight, Bias).

-file("src/viva_tensor.gleam", 5709).
?DOC(" INT8 2:4 sparse linear with auto-shape backend dispatch.\n").
-spec linear_int8_sparse(
    viva_tensor@tensor:tensor(),
    viva_tensor@native@inference:packed_weight_int8_sparse(),
    gleam@option:option(viva_tensor@tensor:tensor())
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_int8_sparse(Input, Weight, Bias) ->
    viva_tensor@native@inference:linear_int8_sparse(Input, Weight, Bias).

-file("src/viva_tensor.gleam", 5718).
?DOC(" FP8 linear fused with bias + GELU activation (cuBLASLt epilogue=36).\n").
-spec linear_gelu_fp8(
    viva_tensor@tensor:tensor(),
    viva_tensor@native@inference:packed_weight_fp8(),
    gleam@option:option(viva_tensor@tensor:tensor())
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_gelu_fp8(Input, Weight, Bias) ->
    viva_tensor@native@inference:linear_gelu_fp8(Input, Weight, Bias).

-file("src/viva_tensor.gleam", 5727).
?DOC(" FP8 SwiGLU block: `silu(input @ gate) * (input @ up)` (+ optional bias).\n").
-spec linear_swiglu_fp8(
    viva_tensor@tensor:tensor(),
    viva_tensor@native@inference:packed_weight_fp8(),
    viva_tensor@native@inference:packed_weight_fp8(),
    gleam@option:option(viva_tensor@tensor:tensor())
) -> {ok, viva_tensor@tensor:tensor()} |
    {error, viva_tensor@core@error:tensor_error()}.
linear_swiglu_fp8(Input, Gate_weight, Up_weight, Bias) ->
    viva_tensor@native@inference:linear_swiglu_fp8(
        Input,
        Gate_weight,
        Up_weight,
        Bias
    ).