Function write_safetensors_file

src/framework/io/safetensors.cpp:352–411

        if (pos < header.size() && header[pos] == '}') {
            ++pos;
            break;
        }
    }

    return index;
}

void write_safetensors_file(
    const std::filesystem::path & path,
    const std::vector<SafeTensorWriteEntry> & entries) {
    if (entries.empty()) {
        throw std::runtime_error("safetensors writer requires at least one tensor");
    }

    std::unordered_set<std::string> names;
    std::vector<std::pair<size_t, size_t>> offsets;
    offsets.reserve(entries.size());
    size_t cursor = 0;
    for (const auto & entry : entries) {
        if (entry.name.empty() || entry.dtype.empty()) {
            throw std::runtime_error("safetensors writer received an unnamed tensor or dtype");
        }
        if (!names.insert(entry.name).second) {
            throw std::runtime_error("safetensors writer received duplicate tensor: " + entry.name);
        }
        for (int64_t dim : entry.shape) {
            if (dim < 0) {
                throw std::runtime_error("safetensors writer received negative shape dimension: " + entry.name);
            }
        }
        offsets.emplace_back(cursor, cursor + entry.data.size());
        cursor += entry.data.size();
    }

    std::ostringstream header_stream;
    header_stream << "{";
    for (size_t i = 0; i < entries.size(); ++i) {
        if (i != 0) {
            header_stream << ",";
        }
        header_stream << "\"" << escape_json_string(entries[i].name) << "\":{";
        header_stream << "\"dtype\":\"" << escape_json_string(entries[i].dtype) << "\",";
        header_stream << "\"shape\":" << shape_to_json(entries[i].shape) << ",";
        header_stream << "\"data_offsets\":[" << offsets[i].first << "," << offsets[i].second << "]";
        header_stream << "}";
    }
    header_stream << "}";

    std::string header = header_stream.str();
    header.append((8 - (header.size() % 8)) % 8, ' ');

    const auto parent = path.parent_path();
    if (!parent.empty()) {
        std::filesystem::create_directories(parent);
    }
    std::ofstream output(path, std::ios::binary | std::ios::trunc);
    if (!output) {
        throw std::runtime_error("failed to open safetensors output file: " + path.string());