@cetapod/react-native-smb 1.0.0

package/cpp/shared/core/SmbTask.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <future>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <NitroModules/HybridObject.hpp>
+#include <jsi/jsi.h>
+
+#include "SmbTaskCore.hpp"
+
+namespace react_native_smb {
+
+class OperatorBase;
+class SmbConnectionPool;
+
+namespace jsi = facebook::jsi;
+using namespace margelo::nitro;
+
+class SmbTask : public HybridObject, public SmbTaskCore {
+   public:
+    SmbTask(std::string id, std::unique_ptr<OperatorBase> seedOp, SmbConnectionPool* pool);
+    ~SmbTask();
+
+    void start();
+    size_t spawn(std::vector<std::unique_ptr<OperatorBase>> moreOps);
+
+    using SmbTaskCore::subscribe;
+
+    std::string getId() { return SmbTaskCore::getId(); }
+    void cancel();
+    std::unordered_map<std::string, std::string> get();
+    std::string subscribeMap(const std::function<void(const std::unordered_map<std::string, std::string>&)>& listener);
+    void unsubscribe(const std::string& id) { SmbTaskCore::unsubscribe(id); }
+
+    std::future<void> result() { return completionFuture(); }
+
+   private:
+    jsi::Value getResultValueRaw(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* args, size_t count);
+    SmbConnectionPool* pool_{nullptr};
+
+    void launchOp(size_t opIndex);
+    size_t appendOps(std::vector<std::unique_ptr<OperatorBase>>& more);
+
+    void loadHybridMethods() override;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/core/SmbTaskCore.cpp

@@ -0,0 +1,222 @@
+#include "SmbTaskCore.hpp"
+
+#include <algorithm>
+#include <chrono>
+
+#include "../operators/OperatorBase.hpp"
+#include "../util/SmbLog.hpp"
+
+namespace react_native_smb {
+
+namespace jsi = facebook::jsi;
+
+int64_t SmbTaskCore::nowMs() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+               std::chrono::system_clock::now().time_since_epoch())
+        .count();
+}
+
+SmbTaskCore::SmbTaskCore(std::string id, SmbOperatorKind kind)
+    : id_(std::move(id)), kind_(kind) {}
+
+SmbTaskCore::~SmbTaskCore() = default;
+
+void SmbTaskCore::cancel() {
+    cancel_.cancel();
+    settle(SmbTaskStatus::Cancelled, "", static_cast<int>(SmbErrorCode::Cancelled));
+}
+
+SmbTaskState SmbTaskCore::getState() const {
+    SmbTaskState s;
+    writeToSnapshot(s);
+    return s;
+}
+
+void SmbTaskCore::setPaths(std::string source, std::string destination) {
+    {
+        std::lock_guard<std::mutex> lk(stateMutex_);
+        sourcePath_ = std::move(source);
+        destinationPath_ = std::move(destination);
+        updatedAt_ = nowMs();
+    }
+    notifyListeners();
+}
+
+void SmbTaskCore::addExpectedBytes(int64_t bytes) {
+    totalBytes_.fetch_add(bytes);
+    notifyListeners();
+}
+
+void SmbTaskCore::onOpStatus(size_t opIndex, SmbTaskStatus s, const std::string& error, int code) {
+    if (settled_.load(std::memory_order_acquire) && s == SmbTaskStatus::Success) return;
+    if (status_.load() == SmbTaskStatus::Cancelled && s == SmbTaskStatus::Success) return;
+    {
+        std::lock_guard<std::mutex> lk(stateMutex_);
+        if (opIndex < opProgress_.size()) opProgress_[opIndex].status = s;
+        if (s == SmbTaskStatus::Error && status_.load() != SmbTaskStatus::Error) {
+            errorMessage_ = error;
+            errorCode_ = code;
+        }
+    }
+    notifyListeners();
+}
+
+void SmbTaskCore::onOpProgress(size_t opIndex, double done, double total) {
+    {
+        std::lock_guard<std::mutex> lk(stateMutex_);
+        if (opIndex < opProgress_.size()) {
+            opProgress_[opIndex].done = static_cast<int64_t>(done);
+            opProgress_[opIndex].total = static_cast<int64_t>(total);
+        }
+        recomputeAggregateLocked();
+    }
+    notifyListeners();
+}
+
+std::string SmbTaskCore::subscribe(SnapshotListener listener) {
+    std::lock_guard<std::mutex> lk(listenersMutex_);
+    std::string id = "lst_" + std::to_string(nextListenerId_++);
+    listeners_[id] = std::move(listener);
+    return id;
+}
+
+void SmbTaskCore::unsubscribe(const std::string& id) {
+    std::lock_guard<std::mutex> lk(listenersMutex_);
+    listeners_.erase(id);
+}
+
+void SmbTaskCore::publishResult(std::any value,
+                                std::function<jsi::Value(jsi::Runtime&, const std::any&)> converter) {
+    resultValue_ = std::move(value);
+    resultConverter_ = std::move(converter);
+}
+
+jsi::Value SmbTaskCore::getResultValue(jsi::Runtime& runtime) const {
+    if (!resultConverter_) return jsi::Value::undefined();
+    try {
+        return resultConverter_(runtime, resultValue_);
+    } catch (...) {
+        return jsi::Value::undefined();
+    }
+}
+
+std::future<void> SmbTaskCore::completionFuture() { return done_.get_future(); }
+
+void SmbTaskCore::markPending() {
+    if (settled_.load(std::memory_order_acquire)) return;
+    status_ = SmbTaskStatus::Pending;
+    if (startedAt_ == 0) startedAt_ = nowMs();
+    updatedAt_ = nowMs();
+    notifyListeners();
+}
+
+void SmbTaskCore::markRunning() {
+    if (settled_.load(std::memory_order_acquire)) return;
+    status_ = SmbTaskStatus::Running;
+    if (startedAt_ == 0) startedAt_ = nowMs();
+    updatedAt_ = nowMs();
+    notifyListeners();
+}
+
+void SmbTaskCore::onOpFinished() {
+    const size_t before = pending_.fetch_sub(1);
+    if (before == 1) maybeSettle();
+}
+
+void SmbTaskCore::recomputeAggregateLocked() {
+    updatedAt_ = nowMs();
+    if (!isDeterminate(kind_)) {
+        progress_ = 0.0;
+        return;
+    }
+    int64_t d = 0, t = 0;
+    for (const auto& p : opProgress_) {
+        d += p.done;
+        t += p.total;
+    }
+    bytesDone_ = d;
+    const int64_t denom = std::max<int64_t>(t, std::max<int64_t>(d, totalBytes_.load()));
+    totalBytes_ = denom;
+    progress_ = (denom > 0) ? (static_cast<double>(d) / static_cast<double>(denom)) : 0.0;
+
+    const int64_t elapsedMs = updatedAt_ - startedAt_;
+    if (elapsedMs > 0 && d > 0) {
+        const double elapsedSec = elapsedMs / 1000.0;
+        bytesPerSecond_ = static_cast<double>(d) / elapsedSec;
+        etaSeconds_ = (denom > d && bytesPerSecond_ > 0.0) ? (static_cast<double>(denom - d) / bytesPerSecond_) : 0.0;
+    }
+}
+
+void SmbTaskCore::writeToSnapshot(SmbTaskState& out) const {
+    std::lock_guard<std::mutex> lk(stateMutex_);
+    out.taskId = id_;
+    out.kind = kind_;
+    out.status = status_.load();
+    out.progress = progress_.load();
+    out.errorCode = errorCode_.load();
+    out.errorMessage = errorMessage_;
+    out.sourcePath = sourcePath_;
+    out.destinationPath = destinationPath_;
+    out.bytesDone = bytesDone_.load();
+    out.totalBytes = totalBytes_.load();
+    out.bytesPerSecond = bytesPerSecond_;
+    out.etaSeconds = etaSeconds_;
+    out.startedAt = startedAt_;
+    out.updatedAt = updatedAt_;
+    out.endedAt = endedAt_;
+}
+
+void SmbTaskCore::notifyListeners() {
+    SmbTaskState snap;
+    writeToSnapshot(snap);
+    std::lock_guard<std::mutex> lk(listenersMutex_);
+    for (auto& [id, fn] : listeners_) {
+        if (fn) fn(snap);
+    }
+}
+
+void SmbTaskCore::maybeSettle() {
+    if (cancel_.cancelled()) return;
+    const auto s = status_.load();
+    // Running: normal IO ops. Idle: pool-direct ops (initialize/connect/listShares) that never
+    // pass through OperatorBase::requestContext and therefore never call markPending/markRunning.
+    if (s == SmbTaskStatus::Running || s == SmbTaskStatus::Idle) {
+        settle(SmbTaskStatus::Success, "", static_cast<int>(SmbErrorCode::Unknown));
+    } else {
+        bool expected = false;
+        if (settled_.compare_exchange_strong(expected, true)) {
+            {
+                std::lock_guard<std::mutex> lk(stateMutex_);
+                endedAt_ = nowMs();
+            }
+            notifyListeners();
+            done_.set_value();
+        }
+    }
+}
+
+void SmbTaskCore::settle(SmbTaskStatus finalStatus, const std::string& error, int code) {
+    // First settle wins — later op throws or emitStatus cannot override terminal state.
+    bool expected = false;
+    if (!settled_.compare_exchange_strong(expected, true)) return;
+    SMB_LOG("Task settle id=%s status=%s code=%d%s%s", id_.c_str(), statusName(finalStatus), code,
+            error.empty() ? "" : " error=", error.empty() ? "" : error.c_str());
+
+    status_ = finalStatus;
+    {
+        std::lock_guard<std::mutex> lk(stateMutex_);
+        if (!error.empty()) errorMessage_ = error;
+        errorCode_ = code;
+        endedAt_ = nowMs();
+        updatedAt_ = endedAt_;
+        if (finalStatus == SmbTaskStatus::Success) {
+            if (isDeterminate(kind_) && totalBytes_.load() > 0) bytesDone_ = totalBytes_.load();
+            progress_ = isDeterminate(kind_) ? 1.0 : 0.0;
+            etaSeconds_ = 0.0;
+        }
+    }
+    notifyListeners();
+    done_.set_value();
+}
+
+}  // namespace react_native_smb

package/cpp/shared/core/SmbTaskCore.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+#include <any>
+#include <atomic>
+#include <cstdint>
+#include <functional>
+#include <future>
+#include <map>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "CancellationToken.hpp"
+#include "SmbEnums.hpp"
+#include "SmbTypes.hpp"
+
+namespace react_native_smb {
+
+class OperatorBase;
+
+namespace jsi = facebook::jsi;
+
+// Thread-safe state, result storage, and subscriber fan-out. No HybridObject,
+// no pool orchestration.
+class SmbTaskCore {
+   public:
+    SmbTaskCore(std::string id, SmbOperatorKind kind);
+    ~SmbTaskCore();
+
+    void cancel();
+    SmbTaskState getState() const;
+    std::string getId() const { return id_; }
+    SmbTaskStatus getStatus() const { return status_.load(); }
+    CancellationToken token() const { return cancel_; }
+
+    void setPaths(std::string source, std::string destination);
+    void addExpectedBytes(int64_t bytes);
+
+    void onOpStatus(size_t opIndex, SmbTaskStatus s, const std::string& error, int code);
+    void onOpProgress(size_t opIndex, double done, double total);
+
+    void publishResult(std::any value, std::function<jsi::Value(jsi::Runtime&, const std::any&)> converter);
+    jsi::Value getResultValue(jsi::Runtime& runtime) const;
+
+    std::string subscribe(SnapshotListener listener);
+    void unsubscribe(const std::string& id);
+
+    std::future<void> completionFuture();
+
+    void markPending();
+    void markRunning();
+
+   protected:
+    struct OpProgress {
+        int64_t done{0};
+        int64_t total{0};
+        SmbTaskStatus status{SmbTaskStatus::Idle};
+    };
+
+    std::vector<std::unique_ptr<OperatorBase>> ops_;
+    std::vector<OpProgress> opProgress_;
+    std::atomic<size_t> pending_{0};
+    CancellationToken cancel_;
+
+    void onOpFinished();
+    void settle(SmbTaskStatus finalStatus, const std::string& error, int code);
+
+    static int64_t nowMs();
+
+    mutable std::mutex stateMutex_;
+
+   private:
+    std::string id_;
+    SmbOperatorKind kind_{SmbOperatorKind::Initialize};
+    std::atomic<SmbTaskStatus> status_{SmbTaskStatus::Idle};
+    std::atomic<double> progress_{0.0};
+    std::atomic<int> errorCode_{0};
+    std::string errorMessage_;
+    std::string sourcePath_;
+    std::string destinationPath_;
+    std::atomic<int64_t> bytesDone_{0};
+    std::atomic<int64_t> totalBytes_{0};
+    double bytesPerSecond_{0.0};
+    double etaSeconds_{0.0};
+    int64_t startedAt_{0};
+    int64_t updatedAt_{0};
+    int64_t endedAt_{0};
+
+    std::promise<void> done_;
+    std::atomic<bool> settled_{false};
+
+    std::map<std::string, SnapshotListener> listeners_;
+    mutable std::mutex listenersMutex_;
+    std::atomic<size_t> nextListenerId_{1};
+
+    std::any resultValue_;
+    std::function<jsi::Value(jsi::Runtime&, const std::any&)> resultConverter_;
+
+    void writeToSnapshot(SmbTaskState& out) const;
+    void notifyListeners();
+    void recomputeAggregateLocked();
+    void maybeSettle();
+};
+
+}  // namespace react_native_smb

package/cpp/shared/core/SmbTypes.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <string>
+
+#include "SmbEnums.hpp"
+
+namespace react_native_smb {
+
+// Immutable snapshot a task broadcasts to its subscribers. Pure data (DTO).
+// Projected to/from a Nitro string map by TaskSnapshotCodec.
+struct SmbTaskState {
+    std::string taskId;
+    SmbOperatorKind kind{SmbOperatorKind::Initialize};
+    SmbTaskStatus status{SmbTaskStatus::Idle};
+    double progress{0.0};  // 0.0 - 1.0 (meaningful only when isDeterminate(kind))
+    int errorCode{0};
+    std::string errorMessage;
+    std::string sourcePath;
+    std::string destinationPath;
+    int64_t bytesDone{0};
+    int64_t totalBytes{0};
+    double bytesPerSecond{0.0};
+    double etaSeconds{0.0};
+    int64_t startedAt{0};
+    int64_t updatedAt{0};
+    int64_t endedAt{0};  // 0 if not settled
+};
+
+// Any subscriber (JS bridge, observer hub, anyone). The task notifies all
+// subscribers without knowing who they are.
+using SnapshotListener = std::function<void(const SmbTaskState&)>;
+
+}  // namespace react_native_smb

package/cpp/shared/core/TaskObserverHub.cpp

@@ -0,0 +1,166 @@
+#include "TaskObserverHub.hpp"
+
+#include "SmbTask.hpp"
+
+namespace react_native_smb {
+
+TaskObserverHub::~TaskObserverHub() {
+    // Unsubscribe from any still-alive tasks.
+    std::unique_lock lock(mutex_);
+    for (auto& [taskId, weak] : tracked_) {
+        if (auto task = weak.lock()) {
+            auto it = taskSubIds_.find(taskId);
+            if (it != taskSubIds_.end()) task->unsubscribe(it->second);
+        }
+    }
+}
+
+void TaskObserverHub::track(const std::shared_ptr<SmbTask>& task) {
+    if (!task) return;
+    // Register as a normal subscriber; the task does not know this is "the hub".
+    std::string subId = task->subscribe([this](const SmbTaskState& s) { onTaskUpdate(s); });
+    std::unique_lock lock(mutex_);
+    tracked_[task->getId()] = task;
+    taskSubIds_[task->getId()] = subId;
+}
+
+void TaskObserverHub::untrack(const std::string& taskId) {
+    std::shared_ptr<SmbTask> task;
+    std::string subId;
+    {
+        std::unique_lock lock(mutex_);
+        if (auto it = tracked_.find(taskId); it != tracked_.end()) {
+            task = it->second.lock();
+            tracked_.erase(it);
+        }
+        if (auto it = taskSubIds_.find(taskId); it != taskSubIds_.end()) {
+            subId = it->second;
+            taskSubIds_.erase(it);
+        }
+    }
+    if (task && !subId.empty()) task->unsubscribe(subId);
+}
+
+void TaskObserverHub::onTaskUpdate(const SmbTaskState& snapshot) {
+    {
+        std::unique_lock lock(mutex_);
+        tasks_[snapshot.taskId] = snapshot;
+        if (snapshot.endedAt != 0) {
+            history_.push_back(snapshot);
+            while (history_.size() > kHistoryMax) history_.pop_front();
+        }
+    }
+    dispatch(snapshot);
+}
+
+void TaskObserverHub::dispatch(const SmbTaskState& snapshot) {
+    std::vector<SnapshotListener> all, transfer, active;
+    {
+        std::shared_lock lock(mutex_);
+        for (auto& [id, fn] : allSubs_) all.push_back(fn);
+        if (isTransfer(snapshot))
+            for (auto& [id, fn] : transferSubs_) transfer.push_back(fn);
+        if (isActive(snapshot))
+            for (auto& [id, fn] : activeSubs_) active.push_back(fn);
+    }
+    for (auto& fn : all)
+        if (fn) fn(snapshot);
+    for (auto& fn : transfer)
+        if (fn) fn(snapshot);
+    for (auto& fn : active)
+        if (fn) fn(snapshot);
+}
+
+bool TaskObserverHub::isTransfer(const SmbTaskState& s) { return isTransferKind(s.kind); }
+
+bool TaskObserverHub::isActive(const SmbTaskState& s) { return s.status == SmbTaskStatus::Running || s.status == SmbTaskStatus::Pending; }
+
+std::string TaskObserverHub::subscribeAll(SnapshotListener listener) {
+    std::unique_lock lock(mutex_);
+    std::string id = "all_" + std::to_string(nextSubId_++);
+    allSubs_[id] = std::move(listener);
+    return id;
+}
+
+std::string TaskObserverHub::subscribeTransfers(SnapshotListener listener) {
+    std::unique_lock lock(mutex_);
+    std::string id = "txf_" + std::to_string(nextSubId_++);
+    transferSubs_[id] = std::move(listener);
+    return id;
+}
+
+std::string TaskObserverHub::subscribeActive(SnapshotListener listener) {
+    std::unique_lock lock(mutex_);
+    std::string id = "act_" + std::to_string(nextSubId_++);
+    activeSubs_[id] = std::move(listener);
+    return id;
+}
+
+void TaskObserverHub::unsubscribe(const std::string& id) {
+    std::unique_lock lock(mutex_);
+    allSubs_.erase(id);
+    transferSubs_.erase(id);
+    activeSubs_.erase(id);
+}
+
+std::vector<SmbTaskState> TaskObserverHub::getAll() const {
+    std::shared_lock lock(mutex_);
+    std::vector<SmbTaskState> out;
+    out.reserve(tasks_.size());
+    for (auto& [id, s] : tasks_) out.push_back(s);
+    return out;
+}
+
+std::vector<SmbTaskState> TaskObserverHub::getTransfers() const {
+    std::shared_lock lock(mutex_);
+    std::vector<SmbTaskState> out;
+    for (auto& [id, s] : tasks_)
+        if (isTransfer(s)) out.push_back(s);
+    return out;
+}
+
+std::vector<SmbTaskState> TaskObserverHub::getActive() const {
+    std::shared_lock lock(mutex_);
+    std::vector<SmbTaskState> out;
+    for (auto& [id, s] : tasks_)
+        if (isActive(s)) out.push_back(s);
+    return out;
+}
+
+std::vector<SmbTaskState> TaskObserverHub::getHistory(size_t limit, size_t offset) const {
+    std::shared_lock lock(mutex_);
+    std::vector<SmbTaskState> out;
+    if (offset >= history_.size()) return out;
+    // history_ is oldest-first; return newest-first for UI.
+    const size_t total = history_.size();
+    size_t startFromEnd = offset;
+    size_t count = 0;
+    for (size_t i = 0; i < total && count < limit; ++i) {
+        size_t idx = total - 1 - i;  // newest first
+        if (i < startFromEnd) continue;
+        out.push_back(history_[idx]);
+        ++count;
+    }
+    return out;
+}
+
+std::shared_ptr<SmbTaskState> TaskObserverHub::getTask(const std::string& id) const {
+    std::shared_lock lock(mutex_);
+    if (auto it = tasks_.find(id); it != tasks_.end()) return std::make_shared<SmbTaskState>(it->second);
+    return nullptr;
+}
+
+void TaskObserverHub::clearHistory(int64_t beforeTs) {
+    std::unique_lock lock(mutex_);
+    if (beforeTs <= 0) {
+        history_.clear();
+        return;
+    }
+    std::deque<SmbTaskState> kept;
+    for (auto& s : history_) {
+        if (s.endedAt >= beforeTs) kept.push_back(s);
+    }
+    history_.swap(kept);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/core/TaskObserverHub.hpp

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <atomic>
+#include <deque>
+#include <map>
+#include <memory>
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "SmbTypes.hpp"
+
+namespace react_native_smb {
+
+class SmbTask;
+
+// Optional, per-instance global view of all tasks (transfer tray, debug panel).
+// NOT a singleton. The hub SUBSCRIBES to tasks via SmbTask::subscribe(); tasks
+// never reference the hub. Removing it leaves the library fully functional.
+class TaskObserverHub {
+   public:
+    TaskObserverHub() = default;
+    ~TaskObserverHub();
+
+    // Start/stop watching a task (called by HybridSMB on createTask / teardown).
+    void track(const std::shared_ptr<SmbTask>& task);
+    void untrack(const std::string& taskId);
+
+    // Downstream subscriptions.
+    std::string subscribeAll(SnapshotListener listener);
+    std::string subscribeTransfers(SnapshotListener listener);  // download/upload/copy/duplicate
+    std::string subscribeActive(SnapshotListener listener);     // Running / Pending
+    void unsubscribe(const std::string& id);
+
+    // Queries.
+    std::vector<SmbTaskState> getAll() const;
+    std::vector<SmbTaskState> getTransfers() const;
+    std::vector<SmbTaskState> getActive() const;
+    std::vector<SmbTaskState> getHistory(size_t limit = 100, size_t offset = 0) const;
+    std::shared_ptr<SmbTaskState> getTask(const std::string& id) const;
+
+    void clearHistory(int64_t beforeTs = 0);
+
+   private:
+    void onTaskUpdate(const SmbTaskState& snapshot);  // the listener registered into each task
+    void dispatch(const SmbTaskState& snapshot);
+    static bool isTransfer(const SmbTaskState& s);
+    static bool isActive(const SmbTaskState& s);
+
+    std::unordered_map<std::string, SmbTaskState> tasks_;       // latest snapshot per task
+    std::unordered_map<std::string, std::string> taskSubIds_;   // taskId -> sub id in that task
+    std::unordered_map<std::string, std::weak_ptr<SmbTask>> tracked_;
+    std::deque<SmbTaskState> history_;
+
+    std::map<std::string, SnapshotListener> allSubs_;
+    std::map<std::string, SnapshotListener> transferSubs_;
+    std::map<std::string, SnapshotListener> activeSubs_;
+
+    mutable std::shared_mutex mutex_;
+    std::atomic<size_t> nextSubId_{1};
+
+    static constexpr size_t kHistoryMax = 2000;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/core/TaskSnapshotCodec.cpp

@@ -0,0 +1,32 @@
+#include "TaskSnapshotCodec.hpp"
+
+#include "SmbEnums.hpp"
+
+namespace react_native_smb {
+
+std::unordered_map<std::string, std::string> TaskSnapshotCodec::encode(const SmbTaskState& s) {
+    return {
+        {Keys::exists, "1"},
+        {Keys::taskId, s.taskId},
+        {Keys::kind, std::to_string(static_cast<int>(s.kind))},
+        {Keys::operation, operationName(s.kind)},
+        {Keys::status, std::to_string(static_cast<int>(s.status))},
+        {Keys::determinate, isDeterminate(s.kind) ? "1" : "0"},
+        {Keys::progress, std::to_string(s.progress)},
+        {Keys::errorCode, std::to_string(s.errorCode)},
+        {Keys::errorMessage, s.errorMessage},
+        {Keys::sourcePath, s.sourcePath},
+        {Keys::destinationPath, s.destinationPath},
+        {Keys::bytesDone, std::to_string(s.bytesDone)},
+        {Keys::totalBytes, std::to_string(s.totalBytes)},
+        {Keys::bytesPerSecond, std::to_string(s.bytesPerSecond)},
+        {Keys::etaSeconds, std::to_string(s.etaSeconds)},
+        {Keys::startedAt, std::to_string(s.startedAt)},
+        {Keys::updatedAt, std::to_string(s.updatedAt)},
+        {Keys::endedAt, std::to_string(s.endedAt)},
+    };
+}
+
+std::unordered_map<std::string, std::string> TaskSnapshotCodec::notFound() { return {{Keys::exists, "0"}}; }
+
+}  // namespace react_native_smb