Checkpoint the party/runtime stack before share-program and malicious-mode work.

Ship the TLS mesh, composer, Beaver/Yao/leaf MPC, prep/online paths, apps, and docs so the tree is pushable before elevating share_expr, security_mode, and prep resume.

Co-authored-by: Cursor <cursoragent@cursor.com>

python/pydpf_types.hpp

@@ -0,0 +1,125 @@
+#pragma once
+
+#include <cstdint>
+#include <iterator>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "dpf.hpp"
+
+namespace pydpf_detail
+{
+
+using point_key0 = decltype(dpf::make_dpf(std::uint8_t{0},
+    std::uint64_t{0}).first);
+using point_key1 = decltype(dpf::make_dpf(std::uint8_t{0},
+    std::uint64_t{0}).second);
+
+using multi_key0 = decltype(dpf::make_dpf(std::uint8_t{0},
+    std::uint64_t{0}, std::uint64_t{0}).first);
+using multi_key1 = decltype(dpf::make_dpf(std::uint8_t{0},
+    std::uint64_t{0}, std::uint64_t{0}).second);
+
+using wild_key0 = decltype(dpf::make_dpf(std::uint8_t{0},
+    dpf::wildcard_value<std::uint64_t>{}).first);
+using wild_key1 = decltype(dpf::make_dpf(std::uint8_t{0},
+    dpf::wildcard_value<std::uint64_t>{}).second);
+
+using idpf_key0 = decltype(dpf::make_dpf(std::uint16_t{0},
+    dpf::idpf_ones<16>()).first);
+using idpf_key1 = decltype(dpf::make_dpf(std::uint16_t{0},
+    dpf::idpf_ones<16>()).second);
+
+struct PointKeyPair
+{
+    point_key0 k0;
+    point_key1 k1;
+};
+
+struct MultiKeyPair
+{
+    multi_key0 k0;
+    multi_key1 k1;
+};
+
+struct WildcardKeyPair
+{
+    wild_key0 k0;
+    wild_key1 k1;
+};
+
+struct IdpfKeyPair
+{
+    idpf_key0 k0;
+    idpf_key1 k1;
+};
+
+struct ItDpf3Keys
+{
+    dpf::it_dpf3_key k0;
+    dpf::it_dpf3_key k1;
+    dpf::it_dpf3_key k2;
+};
+
+template <typename Share, typename = void>
+struct has_raw_member : std::false_type {};
+template <typename Share>
+struct has_raw_member<Share,
+    std::void_t<decltype(std::declval<const Share &>().raw())>>
+    : std::true_type {};
+
+template <typename Share>
+std::uint64_t share_limb(const Share & s)
+{
+    if constexpr (has_raw_member<Share>::value)
+        return static_cast<std::uint64_t>(s.raw());
+    else
+        return static_cast<std::uint64_t>(s);
+}
+
+template <typename Iterable>
+std::vector<std::uint64_t> collect_limbs(Iterable && iterable)
+{
+    std::vector<std::uint64_t> out;
+    for (auto it = std::begin(iterable); it != std::end(iterable); ++it)
+        out.push_back(share_limb(*it));
+    return out;
+}
+
+/// In-process wildcard leaf assign (same messages as asio, no socket).
+template <std::size_t I = 0, typename DpfKey0, typename DpfKey1, typename ShareT>
+void assign_leaf_local(DpfKey0 & dpf0, DpfKey1 & dpf1, const ShareT & shr0,
+    const ShareT & shr1)
+{
+    auto & w0 = std::get<I>(dpf0.leaf_nodes);
+    auto & w1 = std::get<I>(dpf1.leaf_nodes);
+    if (w0.is_ready())
+        w0.begin_update();
+    if (w1.is_ready())
+        w1.begin_update();
+    const auto b0 = w0.compute_and_get_blinded_output_share(shr0);
+    const auto b1 = w1.compute_and_get_blinded_output_share(shr1);
+    const auto l0 = w0.compute_and_get_leaf_share(b1);
+    const auto l1 = w1.compute_and_get_leaf_share(b0);
+    w0.reconstruct_correction_word(l1);
+    w1.reconstruct_correction_word(l0);
+}
+
+inline void require_party(int party)
+{
+    if (party != 0 && party != 1)
+        throw std::invalid_argument("party must be 0 or 1");
+}
+
+inline void require_sorted(const std::vector<std::uint8_t> & xs)
+{
+    for (std::size_t i = 1; i < xs.size(); ++i)
+    {
+        if (xs[i] < xs[i - 1])
+            throw std::invalid_argument("sequence points must be nondecreasing");
+    }
+}
+
+}  // namespace pydpf_detail