session-foundation · jagerman · Feb 13, 2026 · Mar 10, 2026 · Mar 10, 2026 · Mar 10, 2026
diff --git a/.clang-format b/.clang-format
@@ -22,7 +22,7 @@ Cpp11BracedListStyle: 'true'
 KeepEmptyLinesAtTheStartOfBlocks: 'true'
 NamespaceIndentation: Inner
 CompactNamespaces: 'true'
-PenaltyBreakString: '3'
+PenaltyBreakString: '1000'
 SpaceBeforeParens: ControlStatements
 SpacesInAngles: 'false'
 SpacesInContainerLiterals: 'false'

diff --git a/.drone.jsonnet b/.drone.jsonnet
@@ -201,6 +201,16 @@ local windows_cross_pipeline(name,
                  }] else [])
 );
 
+local live_test_step(image, mode) = {
+  name: 'live tests (' + mode + ')',
+  image: image,
+  pull: 'always',
+  commands: apt_setup(image, default_test_deps) + [
+    'cd build',
+    './tests/testLive --' + mode + ' --log-level warning --colour-mode ansi -d yes "[file]"',
+  ],
+};
+
 // Live Pro-backend integration test: build testAll with the dev-server hook, stand up an ephemeral
 // backend (throwaway postgres + flask, provider_dry_run) via tests/pro_backend/run-dev-backend.sh,
 // and run the [pro_live] suite against it. The backend is a separate Python service, checked out at
@@ -409,6 +419,20 @@ local static_build(name,
   // Various debian builds
   debian_build('Debian sid', docker_base + 'debian-sid'),
 
+  // Debian sid with session-router + live file transfer tests
+  local live_image = docker_base + 'debian-sid';
+  debian_build(
+    'Debian sid (live tests)',
+    live_image,
+    cmake_extra='-DENABLE_NETWORKING=ON -DENABLE_NETWORKING_SROUTER=ON -DBUILD_LIVE_TESTS=ON',
+  ) + {
+    steps: super.steps + [
+      live_test_step(live_image, 'onionreq'),
+      live_test_step(live_image, 'srouter'),
+      live_test_step(live_image, 'direct'),
+    ],
+  },
+
   // Live Pro-backend integration tests (ephemeral backend + [pro_live]).
   pro_backend_live_pipeline('Debian sid (Pro backend live)', docker_base + 'debian-sid'),
 
@@ -426,7 +450,7 @@ local static_build(name,
   debian_build('Debian stable (armhf)', docker_base + 'debian-stable/arm32v7', arch='arm64', jobs=4),
 
   // Macos builds:
-  mac_builder('macOS Intel (Release)', allow_test_fail=true/*the current intel mac has issues*/),
+  //mac_builder('macOS Intel (Release)', allow_test_fail=true/*the current intel mac has issues*/),
   mac_builder('macOS Arm64 (Release)', arch='arm64'),
   mac_builder('macOS Arm64 (Debug)', arch='arm64', build_type='Debug'),
 

diff --git a/.gitignore b/.gitignore
@@ -1,5 +1,6 @@
 /build*/
 /compile_commands.json
 /.cache/
+/.claude/
 /.vscode/
 .DS_STORE
diff --git a/.gitmodules b/.gitmodules
@@ -1,24 +1,21 @@
-[submodule "external/libsodium-internal"]
-    path = external/libsodium-internal
-    url = https://github.com/session-foundation/libsodium-internal.git
 [submodule "tests/Catch2"]
 	path = tests/Catch2
 	url = https://github.com/catchorg/Catch2
 [submodule "external/ios-cmake"]
 	path = external/ios-cmake
 	url = https://github.com/leetal/ios-cmake
-[submodule "external/zstd"]
-	path = external/zstd
-	url = https://github.com/facebook/zstd.git
 [submodule "external/protobuf"]
 	path = external/protobuf
 	url = https://github.com/protocolbuffers/protobuf.git
 [submodule "external/session-router"]
 	path = external/session-router
 	url = https://github.com/session-foundation/session-router.git
-[submodule "external/simdutf"]
-	path = external/simdutf
-	url = https://github.com/simdutf/simdutf.git
+[submodule "external/session-sqlite"]
+	path = external/session-sqlite
+	url = https://github.com/session-foundation/session-sqlite.git
 [submodule "external/date"]
 	path = external/date
 	url = https://github.com/HowardHinnant/date.git
+[submodule "cmake/session-deps"]
+	path = cmake/session-deps
+	url = https://github.com/session-foundation/session-deps.git
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -0,0 +1,79 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+
+```bash
+# Configure (out-of-source build required)
+cmake -G Ninja -S . -B build-claude
+
+# Build
+cmake --build build-claude --parallel --verbose
+
+# Run tests
+./build-claude/tests/testAll [test-tag-or-name]
+
+# Regenerate protobuf files
+cmake --build build-claude --target regen-protobuf --parallel
+```
+
+### Notable CMake Options
+
+- `-DBUILD_STATIC_DEPS=ON` — force all deps to build statically (no system libs)
+- `-DENABLE_ONIONREQ=ON/OFF` — include onion request / network functionality (default ON)
+- `-DWARNINGS_AS_ERRORS=ON` — treat warnings as errors
+- `-DSUBMODULE_CHECK=OFF` — skip submodule freshness checks (useful during dev)
+
+## Architecture Overview
+
+This is **libsession-util**, the C++20 utility library for Session clients. It provides:
+
+1. **Cryptographic primitives** (`libsession::crypto`) — Ed25519/X25519 keys, blinding, hashing, encryption (session protocol, multi-encrypt, attachments), XEd25519 signatures.
+
+2. **Config sync system** (`libsession::config`) — CRDT-style distributed config that syncs across Session devices via swarm storage. Each config type has a namespace:
+   - `UserProfile`, `Contacts`, `ConvoInfoVolatile`, `UserGroups` — per-user configs
+   - `GroupKeys`, `GroupInfo`, `GroupMembers` — shared group configs (closed groups)
+   - `Local` — device-local config (never pushed to swarm)
+   - Config messages use bt-encoding (bencode), seqno-based CRDT merge with deterministic tie-breaking. See `docs/api/docs/config_merge_logic.md` for protocol details.
+
+3. **Core** (`libsession::core`) — Persistent client state backed by SQLite. The `Core` class owns `CoreComponent`-derived members (`Globals`, `Devices`, `Pro`) that share a connection pool. Migrations live in `src/core/schema/` as `NNN_name.sql` or `NNN_name.cpp` files.
+
+4. **Onion requests** (`libsession::onionreq`, optional) — Builder/parser for onion-routed requests to the Session network.
+
+### Library Targets and Dependencies
+
+```
+util     ← file, logging, util (uses zstd, simdutf)
+crypto   ← util + libsodium (blinding, ed25519, session_encrypt, etc.)
+config   ← crypto + libsodium + protos (all config types)
+core     ← crypto + SQLite + mlkem768 (PQC key encapsulation)
+onionreq ← crypto + quic + nettle (optional)
+```
+
+All targets are aliased as `libsession::util`, `libsession::crypto`, etc.
+
+### Header Layout
+
+Public headers are in `include/session/`:
+- `include/session/config/` — config type headers (`.h` = C API, `.hpp` = C++ API)
+- `include/session/config/groups/` — closed group configs (keys, info, members)
+- `include/session/core/` — Core persistent state components
+- `include/session/onionreq/` — onion request types
+
+### Dependency System
+
+Dependencies are managed via `cmake/session-deps/` which provides `session_dep()` and `session_dep_or_submodule()` macros. These first try system libraries; if not found they fall back to static builds. External submodules live in `external/` (oxen-logging, nlohmann-json, ios-cmake, protobuf, oxen-libquic).
+
+### Tests
+
+Tests use Catch2. Most tests are compiled into `testAll`; logging tests are isolated in `testLogging` because they modify global sink/level state. Filter tests with Catch2 tag syntax, e.g. `./Build/tests/testAll "[config]"`.
+
+### Dual C/C++ API
+
+Many headers come in pairs: `foo.h` (C API for FFI use) and `foo.hpp` (C++ API).  The C API generally is a wrapper around the primary C++ API.  When adding new public functionality, consider whether a C API is needed.
+
+## Code Style
+
+- **Prefer DRY code**: when logic is duplicated across two or more call sites, extract a shared helper.  Do this proactively when writing new code, not only when asked.
+- **Specify the shape upfront**: when asked to implement something that overlaps with existing code, identify and extract the shared piece before writing the new code, so duplication never appears in the first place.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -17,7 +17,7 @@ if(CCACHE_PROGRAM)
 endif()
 
 project(libsession-util
-    VERSION 1.7.0
+    VERSION 1.6.3
     DESCRIPTION "Session client utility library"
     LANGUAGES ${LANGS})
 
@@ -58,11 +58,16 @@ else()
     set(static_default ON)
 endif()
 
-option(BUILD_STATIC_DEPS "Build all dependencies statically rather than trying to link to them on the system" ${static_default})
+# Override the default OFF value set in cmake/session-deps/Deps.cmake so that BUILD_STATIC_DEPS
+# defaults to the same value as BUILD_SHARED_LIBS (i.e. static by default).
+set(BUILD_STATIC_DEPS ${static_default} CACHE BOOL "Build all dependencies statically rather than trying to link to them on the system")
+
+include(cmake/session-deps/Deps.cmake)
+
 option(STATIC_BUNDLE "Build a single static .a containing everything (both code and dependencies)" ${BUILD_STATIC_DEPS})
 
 if(STATIC_BUNDLE AND NOT BUILD_STATIC_DEPS)
-    message(FATAL_ERROR "STATIC_BUNDLE requires BUILD_STATIC_DEPS=ON (cannot build a static bundle when using shared/system libs)")
+    message(FATAL_ERROR "STATIC_BUNDLE requires BUILD_STATIC_DEPS to be enabled")
 endif()
 
 if(BUILD_SHARED_LIBS OR libsession_IS_TOPLEVEL_PROJECT)
@@ -79,16 +84,15 @@ else()
   set(use_lto_default ON)
 endif()
 
-option(WARNINGS_AS_ERRORS "Treat all compiler warnings as errors" OFF)
 option(WARN_UNUSED_PARAMETERS "Enabled unused parameter warnings" ON)
+option(WARNINGS_AS_ERRORS "Treat all compiler warnings as errors" OFF)
+option(FATAL_MISSING_DECLARATIONS "Developer/CI option: fatal error on non-static definitions without prior declarations (-Werror=missing-declarations)" OFF)
 
 option(STATIC_LIBSTD "Statically link libstdc++/libgcc" ${default_static_libstd})
 
 option(USE_LTO "Use Link-Time Optimization" ${use_lto_default})
 
-# Provide this as an option for now because GMP and Desktop are sometimes unhappy with each other.
-option(ENABLE_NETWORKING "Build with networking functionality" ON)
-option(ENABLE_NETWORKING_SROUTER "Build with session-router networking support (requires ENABLE_NETWORKING)" ON)
+option(ENABLE_NETWORKING_SROUTER "Build with session-router networking support" ON)
 
 if(USE_LTO)
   include(CheckIPOSupported)
@@ -107,6 +111,17 @@ if(IPO_ENABLED AND NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION)
   set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ON)
 endif()
 
+# USE_LTO is the single LTO knob.  Two submodule-provided options default ON independently of it:
+# SESSIONDEPS_LTO (session-deps, several copies sharing one cache variable) controls LTO for static
+# dependency builds, and WITH_LTO (session-router's enable_lto.cmake) controls LTO for session-router's
+# own targets.  Leaving either ON in a non-LTO build breaks the link: LTO'd static archives can't be
+# consumed by a non-LTO link -- clang in particular emits pure bitcode archives that a plain bfd link
+# reports as "file format not recognized", or silently drops the members (undefined references).  Force
+# both to follow USE_LTO, seeding these shared cache variables before any submodule evaluates its own
+# option() so there is exactly one LTO switch.
+set(SESSIONDEPS_LTO ${USE_LTO} CACHE BOOL "Use LTO for static dependency builds, where supported" FORCE)
+set(WITH_LTO ${USE_LTO} CACHE BOOL "enable lto on compile time" FORCE)
+
 if(STATIC_LIBSTD)
     add_link_options(-static-libstdc++)
     if(NOT CMAKE_CXX_COMPILER_ID MATCHES Clang)
@@ -122,30 +137,22 @@ include(AddStaticBundleLib)
 # Always build PIC
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
+# For a static-deps build we build everything from source; don't let oxen-logging pick up system
+# fmt/spdlog via find_package.  Beyond the usual reasons to prefer our own versions, a system
+# fmt/spdlog is built against libstdc++ and cannot be linked into a libc++ build (undefined
+# std::__1 symbols), so force the bundled submodules which build with our toolchain.
+if(BUILD_STATIC_DEPS)
+    set(OXEN_LOGGING_FORCE_SUBMODULES ON CACHE INTERNAL "")
+endif()
+
 
 add_subdirectory(external)
 
-if(ENABLE_NETWORKING)
-    if(NOT TARGET nettle::nettle)
-        if(BUILD_STATIC_DEPS)
-            message(FATAL_ERROR "Internal error: nettle::nettle target (expected via libquic BUILD_STATIC_DEPS) not found")
-        else()
-            find_package(PkgConfig REQUIRED)
-            pkg_check_modules(NETTLE REQUIRED IMPORTED_TARGET nettle)
-            add_library(nettle INTERFACE)
-            target_link_libraries(nettle INTERFACE PkgConfig::NETTLE)
-            add_library(nettle::nettle ALIAS nettle)
-        endif()
-    endif()
-endif()
+session_dep(nettle 3)
 
 add_subdirectory(src)
 add_subdirectory(proto)
 
-if (BUILD_STATIC_DEPS)
-    include(StaticBuild)
-endif()
-
 if(STATIC_BUNDLE)
 
     include(combine_archives)