transcribe-cpp-sys 0.0.1

// arch/funasr_nano/weights.cpp - read_funasr_nano_hparams +
// build_funasr_nano_weights.
//
// Pattern mirrors src/arch/qwen3_asr/weights.cpp (audio-llm) and
// src/arch/sensevoice/weights.cpp (the encoder catalog is a pruned fork
// of sensevoice — no prefix-embedding table, no CMVN, no CTC head).

#include "weights.h"

#include "transcribe-meta.h"
#include "transcribe-weights-util.h"
#include "transcribe-log.h"

#include "ggml.h"
#include "gguf.h"

#include <cstdio>

namespace transcribe::funasr_nano {

namespace {
constexpr const char * kFamilyTag = "funasr_nano";
}

transcribe_status read_funasr_nano_hparams(const gguf_context *  gguf,
                                           FunAsrNanoHParams &   hp)
{
    if (gguf == nullptr) {
        return TRANSCRIBE_ERR_INVALID_ARG;
    }

    // Encoder.
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.n_blocks",   kFamilyTag, hp.enc_n_blocks);    st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.tp_blocks",  kFamilyTag, hp.enc_tp_blocks);   st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_model",    kFamilyTag, hp.enc_d_model);     st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_input",    kFamilyTag, hp.enc_d_input);     st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.n_heads",    kFamilyTag, hp.enc_n_heads);     st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.d_ff",       kFamilyTag, hp.enc_d_ff);        st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.kernel_size",kFamilyTag, hp.enc_kernel);      st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.encoder.sanm_shift", kFamilyTag, hp.enc_sanm_shift);  st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_string_kv(gguf, "stt.funasr_nano.encoder.attention_type", kFamilyTag, hp.enc_attn_type); st != TRANSCRIBE_OK) return st;
    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.encoder.normalize_before", kFamilyTag, true, hp.enc_normalize_before); st != TRANSCRIBE_OK) return st;

    // Adaptor.
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.n_blocks",      kFamilyTag, hp.adaptor_n_blocks);      st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.encoder_dim",   kFamilyTag, hp.adaptor_encoder_dim);   st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.llm_dim",       kFamilyTag, hp.adaptor_llm_dim);       st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.pre_ffn_dim",   kFamilyTag, hp.adaptor_pre_ffn_dim);   st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.block_ffn_dim", kFamilyTag, hp.adaptor_block_ffn_dim); st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.n_heads",       kFamilyTag, hp.adaptor_n_heads);       st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.d_head",        kFamilyTag, hp.adaptor_d_head);        st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_f32_kv(gguf, "stt.funasr_nano.adaptor.layer_norm_eps", kFamilyTag, hp.adaptor_layer_norm_eps); st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_string_kv(gguf, "stt.funasr_nano.adaptor.activation", kFamilyTag, hp.adaptor_activation); st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.adaptor.downsample_rate", kFamilyTag, hp.adaptor_downsample_rate); st != TRANSCRIBE_OK) return st;
    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.adaptor.use_low_frame_rate", kFamilyTag, true, hp.adaptor_use_low_frame_rate); st != TRANSCRIBE_OK) return st;

    // Decoder (Qwen3-0.6B).
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_layers",        kFamilyTag, hp.dec_n_layers);     st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.hidden_size",     kFamilyTag, hp.dec_hidden);       st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.intermediate_size",kFamilyTag, hp.dec_intermediate); st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_heads",         kFamilyTag, hp.dec_n_heads);      st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.n_kv_heads",      kFamilyTag, hp.dec_n_kv_heads);   st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.head_dim",        kFamilyTag, hp.dec_head_dim);     st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.vocab_size",      kFamilyTag, hp.dec_vocab_size);   st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf, "stt.funasr_nano.decoder.max_position_embeddings", kFamilyTag, hp.dec_max_position_embeddings); st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_f32_kv(gguf, "stt.funasr_nano.decoder.rms_norm_eps",    kFamilyTag, hp.dec_rms_norm_eps); st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_f32_kv(gguf, "stt.funasr_nano.decoder.rope_theta",      kFamilyTag, hp.dec_rope_theta);   st != TRANSCRIBE_OK) return st;
    if (auto st = read_optional_bool_kv(gguf, "stt.funasr_nano.decoder.tie_word_embeddings", kFamilyTag, true, hp.dec_tie_word_embeddings); st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_string_kv(gguf, "stt.funasr_nano.decoder.activation",   kFamilyTag, hp.dec_activation);   st != TRANSCRIBE_OK) return st;

    // Frontend.
    if (auto st = read_required_string_kv(gguf, "stt.frontend.type",      kFamilyTag, hp.fe_type);          st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.num_mels",  kFamilyTag, hp.fe_num_mels);      st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.sample_rate",kFamilyTag, hp.fe_sample_rate);  st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.n_fft",     kFamilyTag, hp.fe_n_fft);         st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.win_length",kFamilyTag, hp.fe_win_length);    st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.hop_length",kFamilyTag, hp.fe_hop_length);    st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_string_kv(gguf, "stt.frontend.window",    kFamilyTag, hp.fe_window);        st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_string_kv(gguf, "stt.frontend.normalize", kFamilyTag, hp.fe_normalize);     st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_string_kv(gguf, "stt.frontend.fbank_style",kFamilyTag, hp.fe_fbank_style);  st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_f32_kv(gguf,    "stt.frontend.dither",    kFamilyTag, hp.fe_dither);        st != TRANSCRIBE_OK) return st;
    if (auto st = read_optional_bool_kv(gguf,   "stt.frontend.upscale_samples", kFamilyTag, true, hp.fe_upscale_samples); st != TRANSCRIBE_OK) return st;
    if (auto st = read_optional_bool_kv(gguf,   "stt.frontend.snip_edges", kFamilyTag, true, hp.fe_snip_edges); st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.lfr_m",     kFamilyTag, hp.fe_lfr_m);         st != TRANSCRIBE_OK) return st;
    if (auto st = read_required_u32_kv(gguf,    "stt.frontend.lfr_n",     kFamilyTag, hp.fe_lfr_n);         st != TRANSCRIBE_OK) return st;
    if (auto st = read_optional_bool_kv(gguf,   "stt.frontend.apply_cmvn",kFamilyTag, false, hp.fe_apply_cmvn); st != TRANSCRIBE_OK) return st;

    // Cross-field invariants.
    if (hp.enc_n_blocks <= 1 || hp.enc_tp_blocks < 0 ||
        hp.enc_d_model <= 0  || hp.enc_d_input <= 0 ||
        hp.enc_n_heads <= 0  || hp.enc_d_ff <= 0    ||
        hp.enc_kernel <= 0   || hp.enc_kernel % 2 == 0)
    {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: encoder hparams invalid (n_blocks=%d "
                     "tp_blocks=%d d_model=%d d_input=%d n_heads=%d d_ff=%d "
                     "kernel=%d — kernel must be positive and odd)",
                     hp.enc_n_blocks, hp.enc_tp_blocks, hp.enc_d_model,
                     hp.enc_d_input, hp.enc_n_heads, hp.enc_d_ff, hp.enc_kernel);
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.enc_d_model % hp.enc_n_heads != 0) {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: encoder d_model (%d) not divisible by n_heads (%d)",
                     hp.enc_d_model, hp.enc_n_heads);
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.enc_d_input != hp.fe_num_mels * hp.fe_lfr_m) {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: encoder d_input (%d) must equal num_mels (%d) "
                     "× lfr_m (%d) = %d",
                     hp.enc_d_input, hp.fe_num_mels, hp.fe_lfr_m,
                     hp.fe_num_mels * hp.fe_lfr_m);
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.enc_attn_type != "sanm") {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: unsupported encoder attention type \"%s\"",
                     hp.enc_attn_type.c_str());
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.adaptor_n_heads <= 0 || hp.adaptor_d_head <= 0 ||
        hp.adaptor_llm_dim != hp.adaptor_n_heads * hp.adaptor_d_head)
    {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: adaptor llm_dim (%d) != n_heads (%d) * d_head (%d)",
                     hp.adaptor_llm_dim, hp.adaptor_n_heads, hp.adaptor_d_head);
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.adaptor_activation != "relu") {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: unsupported adaptor activation \"%s\" "
                     "(only \"relu\" is implemented)",
                     hp.adaptor_activation.c_str());
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.dec_n_layers <= 0 || hp.dec_hidden <= 0 || hp.dec_n_heads <= 0 ||
        hp.dec_n_kv_heads <= 0 || hp.dec_head_dim <= 0 || hp.dec_intermediate <= 0)
    {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR, "funasr_nano: decoder hparams must be positive");
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.dec_n_heads % hp.dec_n_kv_heads != 0) {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: dec n_heads (%d) not divisible by n_kv_heads (%d)",
                     hp.dec_n_heads, hp.dec_n_kv_heads);
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.dec_activation != "silu" && hp.dec_activation != "swish") {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: unsupported decoder activation \"%s\"",
                     hp.dec_activation.c_str());
        return TRANSCRIBE_ERR_GGUF;
    }
    if (!hp.dec_tie_word_embeddings) {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: decoder.tie_word_embeddings=false is not supported "
                     "(graph reuses dec.token_embd.weight as the lm_head)");
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.adaptor_llm_dim != hp.dec_hidden) {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: adaptor.llm_dim (%d) != decoder.hidden_size (%d)",
                     hp.adaptor_llm_dim, hp.dec_hidden);
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.fe_type != "kaldi_fbank_lfr") {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: unsupported frontend type \"%s\"",
                     hp.fe_type.c_str());
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.fe_window != "hamming") {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: unsupported frontend window \"%s\"",
                     hp.fe_window.c_str());
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.fe_normalize != "none") {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: unsupported frontend normalize \"%s\" "
                     "(only \"none\" is implemented; CMVN was dropped at convert)",
                     hp.fe_normalize.c_str());
        return TRANSCRIBE_ERR_GGUF;
    }
    if (hp.fe_fbank_style != "kaldi_htk") {
        log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                     "funasr_nano: unsupported fbank_style \"%s\"",
                     hp.fe_fbank_style.c_str());
        return TRANSCRIBE_ERR_GGUF;
    }
    return TRANSCRIBE_OK;
}

// ---------------------------------------------------------------------------
// Tensor catalog
// ---------------------------------------------------------------------------

namespace {

using transcribe::weights::find_tensor;
using transcribe::weights::lname;

constexpr const char * kTag = kFamilyTag;

#define GET_F32(slot, name, ...) \
    do { \
        ggml_tensor * _t = find_tensor( \
            ctx_meta, (name), \
            {GGML_TYPE_F32}, {__VA_ARGS__}, kTag); \
        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
        (slot) = _t; \
    } while (0)

#define GET_CONV(slot, name, ...) \
    do { \
        ggml_tensor * _t = find_tensor( \
            ctx_meta, (name), \
            {TRANSCRIBE_QUANT_CONV_TYPES}, \
            {__VA_ARGS__}, kTag); \
        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
        (slot) = _t; \
    } while (0)

#define GET_LIN(slot, name, ...) \
    do { \
        ggml_tensor * _t = find_tensor( \
            ctx_meta, (name), \
            {TRANSCRIBE_QUANT_LINEAR_TYPES}, \
            {__VA_ARGS__}, kTag); \
        if (_t == nullptr) return TRANSCRIBE_ERR_GGUF; \
        (slot) = _t; \
    } while (0)

transcribe_status load_enc_block(ggml_context *  ctx_meta,
                                 const char *    prefix,
                                 int64_t         d_in,
                                 int64_t         d_model,
                                 int64_t         d_ff,
                                 int64_t         kernel,
                                 EncBlock &      b)
{
    std::string p = prefix;

    GET_F32(b.norm_attn_w,  (p + ".norm_attn.weight").c_str(), d_in);
    GET_F32(b.norm_attn_b,  (p + ".norm_attn.bias").c_str(),   d_in);
    GET_LIN(b.attn_qkv_w,   (p + ".attn.qkv.weight").c_str(),  d_in, 3 * d_model);
    GET_F32(b.attn_qkv_b,   (p + ".attn.qkv.bias").c_str(),    3 * d_model);
    GET_LIN(b.attn_out_w,   (p + ".attn.out.weight").c_str(),  d_model, d_model);
    GET_F32(b.attn_out_b,   (p + ".attn.out.bias").c_str(),    d_model);
    GET_CONV(b.attn_fsmn_w, (p + ".attn.fsmn.weight").c_str(), kernel, 1, d_model);
    GET_F32(b.norm_ffn_w,   (p + ".norm_ffn.weight").c_str(),  d_model);
    GET_F32(b.norm_ffn_b,   (p + ".norm_ffn.bias").c_str(),    d_model);
    GET_LIN(b.ffn_fc1_w,    (p + ".ffn.fc1.weight").c_str(),   d_model, d_ff);
    GET_F32(b.ffn_fc1_b,    (p + ".ffn.fc1.bias").c_str(),     d_ff);
    GET_LIN(b.ffn_fc2_w,    (p + ".ffn.fc2.weight").c_str(),   d_ff, d_model);
    GET_F32(b.ffn_fc2_b,    (p + ".ffn.fc2.bias").c_str(),     d_model);
    return TRANSCRIBE_OK;
}

transcribe_status load_adaptor_block(ggml_context *  ctx_meta,
                                     const char *    prefix,
                                     int64_t         llm_dim,
                                     int64_t         block_ffn_dim,
                                     AdaptorBlock &  b)
{
    std::string p = prefix;

    GET_F32(b.norm_attn_w, (p + ".norm_attn.weight").c_str(), llm_dim);
    GET_F32(b.norm_attn_b, (p + ".norm_attn.bias").c_str(),   llm_dim);
    GET_LIN(b.attn_q_w,    (p + ".attn.q.weight").c_str(),    llm_dim, llm_dim);
    GET_F32(b.attn_q_b,    (p + ".attn.q.bias").c_str(),      llm_dim);
    GET_LIN(b.attn_k_w,    (p + ".attn.k.weight").c_str(),    llm_dim, llm_dim);
    GET_F32(b.attn_k_b,    (p + ".attn.k.bias").c_str(),      llm_dim);
    GET_LIN(b.attn_v_w,    (p + ".attn.v.weight").c_str(),    llm_dim, llm_dim);
    GET_F32(b.attn_v_b,    (p + ".attn.v.bias").c_str(),      llm_dim);
    GET_LIN(b.attn_out_w,  (p + ".attn.out.weight").c_str(),  llm_dim, llm_dim);
    GET_F32(b.attn_out_b,  (p + ".attn.out.bias").c_str(),    llm_dim);
    GET_F32(b.norm_ffn_w,  (p + ".norm_ffn.weight").c_str(),  llm_dim);
    GET_F32(b.norm_ffn_b,  (p + ".norm_ffn.bias").c_str(),    llm_dim);
    GET_LIN(b.ffn_fc1_w,   (p + ".ffn.fc1.weight").c_str(),   llm_dim, block_ffn_dim);
    GET_F32(b.ffn_fc1_b,   (p + ".ffn.fc1.bias").c_str(),     block_ffn_dim);
    GET_LIN(b.ffn_fc2_w,   (p + ".ffn.fc2.weight").c_str(),   block_ffn_dim, llm_dim);
    GET_F32(b.ffn_fc2_b,   (p + ".ffn.fc2.bias").c_str(),     llm_dim);
    return TRANSCRIBE_OK;
}

} // namespace

transcribe_status build_funasr_nano_weights(ggml_context *             ctx_meta,
                                            const FunAsrNanoHParams &  hp,
                                            FunAsrNanoWeights &        weights)
{
    if (ctx_meta == nullptr) {
        return TRANSCRIBE_ERR_INVALID_ARG;
    }

    const int64_t d_input  = hp.enc_d_input;
    const int64_t d_model  = hp.enc_d_model;
    const int64_t d_ff     = hp.enc_d_ff;
    const int64_t kernel   = hp.enc_kernel;

    // ----- encoder: encoders0[0] (560 → 512 projection) -----
    if (auto st = load_enc_block(ctx_meta, "enc.encoders0.0",
                                 /*d_in=*/d_input, d_model, d_ff, kernel,
                                 weights.encoders0);
        st != TRANSCRIBE_OK) return st;

    // ----- encoder: encoders[0..n_blocks-2] -----
    weights.encoders.assign(hp.enc_n_blocks - 1, EncBlock{});
    for (int i = 0; i < hp.enc_n_blocks - 1; ++i) {
        char prefix[64];
        std::snprintf(prefix, sizeof(prefix), "enc.encoders.%d", i);
        if (auto st = load_enc_block(ctx_meta, prefix, d_model, d_model,
                                     d_ff, kernel, weights.encoders[i]);
            st != TRANSCRIBE_OK) return st;
    }

    // ----- encoder: after_norm -----
    GET_F32(weights.after_norm_w, "enc.after_norm.weight", d_model);
    GET_F32(weights.after_norm_b, "enc.after_norm.bias",   d_model);

    // ----- encoder: tp_encoders[0..tp_blocks-1] -----
    weights.tp_encoders.assign(hp.enc_tp_blocks, EncBlock{});
    for (int i = 0; i < hp.enc_tp_blocks; ++i) {
        char prefix[64];
        std::snprintf(prefix, sizeof(prefix), "enc.tp_encoders.%d", i);
        if (auto st = load_enc_block(ctx_meta, prefix, d_model, d_model,
                                     d_ff, kernel, weights.tp_encoders[i]);
            st != TRANSCRIBE_OK) return st;
    }

    // ----- encoder: tp_norm -----
    GET_F32(weights.tp_norm_w, "enc.tp_norm.weight", d_model);
    GET_F32(weights.tp_norm_b, "enc.tp_norm.bias",   d_model);

    // ----- adaptor: linear1 / linear2 -----
    const int64_t encoder_dim   = hp.adaptor_encoder_dim;
    const int64_t llm_dim       = hp.adaptor_llm_dim;
    const int64_t pre_ffn_dim   = hp.adaptor_pre_ffn_dim;
    const int64_t block_ffn_dim = hp.adaptor_block_ffn_dim;
    GET_LIN(weights.adaptor.linear1_w, "adaptor.linear1.weight", encoder_dim, pre_ffn_dim);
    GET_F32(weights.adaptor.linear1_b, "adaptor.linear1.bias",   pre_ffn_dim);
    GET_LIN(weights.adaptor.linear2_w, "adaptor.linear2.weight", pre_ffn_dim, llm_dim);
    GET_F32(weights.adaptor.linear2_b, "adaptor.linear2.bias",   llm_dim);

    // ----- adaptor blocks -----
    weights.adaptor.blocks.assign(hp.adaptor_n_blocks, AdaptorBlock{});
    for (int i = 0; i < hp.adaptor_n_blocks; ++i) {
        char prefix[64];
        std::snprintf(prefix, sizeof(prefix), "adaptor.blocks.%d", i);
        if (auto st = load_adaptor_block(ctx_meta, prefix, llm_dim,
                                         block_ffn_dim,
                                         weights.adaptor.blocks[i]);
            st != TRANSCRIBE_OK) return st;
    }

    // ----- decoder: token embed (tied to lm_head) -----
    {
        ggml_tensor * tw = ggml_get_tensor(ctx_meta, "dec.token_embd.weight");
        if (tw == nullptr) {
            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                         "funasr_nano: missing tensor \"dec.token_embd.weight\"");
            return TRANSCRIBE_ERR_GGUF;
        }
        if (tw->ne[0] != hp.dec_hidden) {
            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                         "funasr_nano: dec.token_embd.weight ne[0]=%lld, expected %lld",
                         static_cast<long long>(tw->ne[0]),
                         static_cast<long long>(hp.dec_hidden));
            return TRANSCRIBE_ERR_GGUF;
        }
        if (tw->ne[1] != hp.dec_vocab_size) {
            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                         "funasr_nano: dec.token_embd.weight ne[1]=%lld, expected %lld",
                         static_cast<long long>(tw->ne[1]),
                         static_cast<long long>(hp.dec_vocab_size));
            return TRANSCRIBE_ERR_GGUF;
        }
        weights.dec_embed.token_w = tw;
    }

    // ----- decoder: layers -----
    const int64_t dec_h  = hp.dec_hidden;
    const int64_t dec_nh = hp.dec_n_heads;
    const int64_t dec_nkv = hp.dec_n_kv_heads;
    const int64_t dec_hd = hp.dec_head_dim;
    const int64_t dec_im = hp.dec_intermediate;
    const int64_t q_out  = dec_nh  * dec_hd;
    const int64_t kv_out = dec_nkv * dec_hd;

    weights.dec_blocks.assign(hp.dec_n_layers, DecBlock{});
    for (int i = 0; i < hp.dec_n_layers; ++i) {
        auto & b = weights.dec_blocks[i];
        GET_F32(b.norm_attn_w, lname("dec.layers.%d.norm_attn.weight", i), dec_h);
        GET_F32(b.norm_ffn_w,  lname("dec.layers.%d.norm_ffn.weight",  i), dec_h);
        GET_LIN(b.attn_q_w,    lname("dec.layers.%d.attn.q.weight",    i), dec_h, q_out);
        GET_LIN(b.attn_k_w,    lname("dec.layers.%d.attn.k.weight",    i), dec_h, kv_out);
        GET_LIN(b.attn_v_w,    lname("dec.layers.%d.attn.v.weight",    i), dec_h, kv_out);
        GET_LIN(b.attn_o_w,    lname("dec.layers.%d.attn.o.weight",    i), q_out, dec_h);
        GET_F32(b.attn_q_norm, lname("dec.layers.%d.attn.q_norm.weight", i), dec_hd);
        GET_F32(b.attn_k_norm, lname("dec.layers.%d.attn.k_norm.weight", i), dec_hd);
        GET_LIN(b.ffn_gate_w,  lname("dec.layers.%d.ffn.gate.weight",  i), dec_h, dec_im);
        GET_LIN(b.ffn_up_w,    lname("dec.layers.%d.ffn.up.weight",    i), dec_h, dec_im);
        GET_LIN(b.ffn_down_w,  lname("dec.layers.%d.ffn.down.weight",  i), dec_im, dec_h);

        if (b.ffn_gate_w->type != b.ffn_up_w->type) {
            log_msg(TRANSCRIBE_LOG_LEVEL_ERROR,
                         "funasr_nano: ffn gate/up dtype mismatch at layer %d", i);
            return TRANSCRIBE_ERR_GGUF;
        }
    }

    // ----- decoder: final norm -----
    GET_F32(weights.dec_final.norm_w, "dec.output_norm.weight", dec_h);

    return TRANSCRIBE_OK;
}

#undef GET_F32
#undef GET_CONV
#undef GET_LIN

} // namespace transcribe::funasr_nano