yeptris 0.6.7.1 → 0.6.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8192f177ce03a9524f7ec6bd078d1a5854bbcf533b53ed8c8d2d7982d07c1761
-  data.tar.gz: 470e8b180e8f1f632c2e616dc9e6b1762ec99b93fc642aa25a988ea3d1214722
+  metadata.gz: 802f22f654de443d6a21a15045b6ebea91b025839f7124fb89854e7c90085926
+  data.tar.gz: 3abdcf9d94d0f514c331e4ece6add4d792320fc9f1298a0ff9c9d212581a0f8c
 SHA512:
-  metadata.gz: acac433987243971017823d89f3ab5edefd89b3b3770d9a85555c71c0296ed50d144c543a7cc2fbbdb2c432b0c5482209db680e1dc8a89ba5e9b4b6a5dc97c9d
-  data.tar.gz: 5dbed07e836272d52b90c1e398ba0bdbb6e82b324498a66e053dd267a0cdba68c6f59f888eaab220270a2e1f05f2c298022899b9716030280396a88218cc6454
+  metadata.gz: 3272f726668c0ffe2aff8e9c6f21315daec5ecc57ac4eee14843a763042dd234d1d19b31b24dd13c432c98f1b31e5b9a1408dbecb3fe6d76e8aa90a6115c5968
+  data.tar.gz: 628a30a67e89e0263820287266d3c7c06ba25793affe012114301047380d3c4c9344fa3b368d546a6aef80599b40d71c41aef2c871d9525b64d2adfc7136f1e0

data/ext/libyeptris/extconf.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Builds the vendored libyeptris at gem-install time so EVERY install
+# carries the engine (the pure `ruby`-platform gem has no prebuilt
+# binary). Platform gems vendor the prebuilt lib at the gem root —
+# when one is present this extension no-ops.
+
+require "mkmf"
+require "fileutils"
+
+gem_root = File.expand_path("../..", __dir__)
+vendored = File.join(gem_root, "vendor", "libyeptris")
+
+prebuilt = ["libyeptris.so", "libyeptris.dylib", "libyeptris.dll",
+            "yeptris.dll"].any? { |n| File.exist?(File.join(gem_root, n)) }
+
+def write_dummy_makefile(reason)
+  File.write("Makefile", <<~MAKE)
+    all:
+    \t@echo "#{reason}"
+    install:
+    clean:
+  MAKE
+end
+
+if prebuilt
+  write_dummy_makefile("yeptris: prebuilt libyeptris ships in this gem; source build skipped")
+elsif !File.directory?(vendored)
+  write_dummy_makefile("yeptris: no vendored libyeptris sources; set YEPTRIS_LIB_PATH at require time")
+elsif find_executable("cmake").nil?
+  write_dummy_makefile("yeptris: cmake not found; set YEPTRIS_LIB_PATH at require time")
+else
+  # Out-of-source into the ext workdir; the shared lib then moves to
+  # the GEM ROOT, where ffi.rb's ladder probes it.
+  build = File.join(Dir.pwd, "libyeptris-build")
+  # BUILD_TESTING (the CMake standard) gates test/ — the vendored
+  # tree ships no test dir; the static target must build because the
+  # unconditional install(TARGETS yeptris_static) expects it
+  args = [
+    "-DCMAKE_BUILD_TYPE=Release",
+    "-DBUILD_TESTING=OFF",
+    "-DYEPTRIS_BUILD_CLI=OFF",
+    "-DYEPTRIS_BUILD_BENCHMARKS=OFF",
+    "-DYEPTRIS_BUILD_SHARED=ON",
+  ]
+  ok = system("cmake", "-S", vendored, "-B", build, *args) &&
+       system("cmake", "--build", build, "--config", "Release")
+  lib = Dir.glob(File.join(build, "**", "libyeptris.{so,dylib}")).first
+  if ok && lib
+    FileUtils.cp(lib, File.join(gem_root, File.basename(lib)))
+    write_dummy_makefile("yeptris: built vendored libyeptris at gem install")
+  else
+    # a failed build must not abort the install — require-time raises
+    # the informative ladder error instead
+    write_dummy_makefile("yeptris: libyeptris source build failed; set YEPTRIS_LIB_PATH at require time")
+  end
+end

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.6.7.1".freeze
+  VERSION = "0.6.7.2".freeze
   # The error hierarchy lives in THIS file (the parent namespace's
   # own file): nested constants do not trigger a parent-constant
   # autoload, and the law forbids internal requires — defining the
@@ -95,16 +95,18 @@ end
 # DLL per supported minor ships and RUBY_VERSION selects. A missing
 # cell (Ruby 3.3 arm64 has no build) falls back LOUDLY to the ladder.
 begin
-  if Gem.win_platform?
-    require "yeptris/native-#{RUBY_VERSION[/\A\d+\.\d+/]}"
-  else
+  # per-minor FIRST everywhere: a single version-agnostic native.so
+  # loads under ANY Ruby (symbols resolve from the host process), and
+  # one built for a different minor is an ABI gamble — Ruby 3.0 ran
+  # a 3.3-built ext and the JSON parse failed. The plain name stays
+  # as the dev-checkout fallback (built for the running Ruby).
+  require "yeptris/native-#{RUBY_VERSION[/\A\d+\.\d+/]}"
+rescue LoadError
+  begin
     require "yeptris/native"
-  end
-rescue LoadError => e
-  if Gem.win_platform?
+  rescue LoadError => e
     warn "yeptris: no precompiled native materializer for Ruby " \
          "#{RUBY_VERSION[/\A\d+\.\d+/]} on this platform " \
          "(#{e.message}); the FFI ladder carries the load"
   end
-  # FFI ladder only
 end

data/vendor/libyeptris/CMakeLists.txt

@@ -0,0 +1,254 @@
+# yeptris — Ultra-fast YAML 1.2 parser, emitter and streamer in C
+# The YAML counterpart of libleptris. Pure C library with CLI and bindings.
+cmake_minimum_required(VERSION 3.20)
+
+project(yeptris
+    VERSION 0.6.7
+    DESCRIPTION "Ultra-fast YAML 1.2 parser, emitter and streamer in C"
+    LANGUAGES C CXX
+)
+
+# C11 (the standard question, settled with evidence 2026-09-18): going
+# C99 needs FOUR downgrades, not one — _Static_assert (fixed: the
+# typedef-array YEPTRIS_CT_ASSERT), typedef redefinition (mapindex.c),
+# _Thread_local (the per-thread error channel) and <stdatomics> (the
+# lock-free handle pool). The last two are architecture-critical and
+# absent from MSVC's C99 mode; pthread TLS / lock-based pools would
+# regress the hot paths and weaken the concurrency contract.
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS OFF)
+
+# C++11 standard for tests and benchmarks.
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# MSVC (the windows CI leg): the C++ suites use designated initializers
+# (a GCC/Clang extension at C++11; MSVC requires C++20), and the test
+# targets — test_conformance included — need test/compat on the include
+# path for the dirent surface.
+if(MSVC)
+    set(CMAKE_CXX_STANDARD 20)
+endif()
+
+# MSVC multi-config: one runtime home so ctest -C Release and the CLI
+# smoke find every exe (the per-target default scattered them)
+if(MSVC)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+endif()
+
+# MSVC's default stack is 1 MiB; the Unix builds run on 8 MiB — deep
+# document paths (the depth guard's teardown) measured against the
+# Unix default get the same room here
+if(MSVC)
+    add_link_options(/STACK:8388608)
+endif()
+
+# ---------------------------------------------------------------- options --
+option(BUILD_TESTING "Build tests" ON)
+option(YEPTRIS_BUILD_CLI "Build the yeptris CLI tool" ON)
+option(YEPTRIS_BUILD_STATIC "Build the static library" ON)
+option(YEPTRIS_BUILD_SHARED "Build the shared library" OFF)
+option(YEPTRIS_BUILD_BENCHMARKS "Build performance benchmarks (TODO.impl/18)" OFF)
+option(YEPTRIS_BUILD_JSONC_COMPAT
+    "Build libyeptris-jsonc: the json-c drop-in migration layer (TODO.impl/21)" ON)
+option(YEPTRIS_WITH_CBOR "Build the CBOR (RFC 8949) codec surface" ON)
+option(YEPTRIS_ENABLE_ASAN "Enable AddressSanitizer" OFF)
+option(YEPTRIS_ENABLE_TSAN "Enable ThreadSanitizer (requires all-TSAN build)" OFF)
+option(YEPTRIS_ENABLE_UBSAN "Enable UndefinedBehaviorSanitizer" OFF)
+option(YEPTRIS_ENABLE_FUZZING "Build libFuzzer harnesses (TODO.impl/19; requires clang)" OFF)
+option(YEPTRIS_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
+
+# LTO: ON for Release/RelWithDebInfo by default (libleptris measured
+# 1.3-3.5x on parse paths); override with -DYEPTRIS_ENABLE_LTO=OFF.
+if(NOT DEFINED YEPTRIS_ENABLE_LTO)
+    if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+        set(YEPTRIS_ENABLE_LTO_DEFAULT ON)
+    else()
+        set(YEPTRIS_ENABLE_LTO_DEFAULT OFF)
+    endif()
+else()
+    set(YEPTRIS_ENABLE_LTO_DEFAULT ${YEPTRIS_ENABLE_LTO})
+endif()
+option(YEPTRIS_ENABLE_LTO "Enable link-time optimization (default ON for Release)" ${YEPTRIS_ENABLE_LTO_DEFAULT})
+
+# ------------------------------------------------------------- sanitizers --
+if(YEPTRIS_ENABLE_ASAN AND YEPTRIS_ENABLE_TSAN)
+    message(FATAL_ERROR "ASAN and TSAN are mutually exclusive")
+endif()
+
+if(YEPTRIS_ENABLE_ASAN)
+    add_compile_options(-fsanitize=address -fno-omit-frame-pointer -g)
+    add_link_options(-fsanitize=address)
+    message(STATUS "AddressSanitizer: ENABLED")
+endif()
+
+if(YEPTRIS_ENABLE_TSAN)
+    add_compile_options(-fsanitize=thread -fno-omit-frame-pointer -g)
+    add_link_options(-fsanitize=thread)
+    message(STATUS "ThreadSanitizer: ENABLED")
+endif()
+
+if(YEPTRIS_ENABLE_UBSAN)
+    add_compile_options(
+        -fsanitize=undefined -fsanitize=float-cast-overflow
+        -fno-sanitize-recover=undefined -fno-omit-frame-pointer -g)
+    add_link_options(-fsanitize=undefined -fsanitize=float-cast-overflow)
+    message(STATUS "UndefinedBehaviorSanitizer: ENABLED (fatal)")
+endif()
+
+# libFuzzer implies ASAN (libleptris TODO 40 pattern).
+if(YEPTRIS_ENABLE_FUZZING)
+    add_compile_options(-fsanitize=fuzzer-no-link,address -fno-omit-frame-pointer -g)
+    add_link_options(-fsanitize=fuzzer,address)
+    message(STATUS "libFuzzer: ENABLED (implies ASAN)")
+endif()
+
+# -------------------------------------------------------------------- LTO --
+if(YEPTRIS_ENABLE_LTO)
+    include(CheckIPOSupported)
+    check_ipo_supported(RESULT yeptris_lto_supported OUTPUT yeptris_lto_error)
+    if(yeptris_lto_supported)
+        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+        message(STATUS "Link-time optimization: ENABLED")
+    else()
+        message(WARNING "YEPTRIS_ENABLE_LTO requested but not supported: ${yeptris_lto_error}")
+    endif()
+endif()
+
+# -------------------------------------------------------------- visibility --
+# Position-independent code for static libraries (embeddable in DSOs).
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Hide all symbols by default; the public surface is exactly the
+# YEPTRIS_API-marked functions (libleptris TODO 80 pattern).
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# ---------------------------------------------------------------- warnings --
+# Scoped per-target so fetched dependencies (GTest) keep their own flags.
+function(yeptris_set_warnings target)
+    if(MSVC)
+        # /wd4100 mirrors -Wno-unused-parameter; /experimental:c11atomics
+        # un-breaks the C11 headers' stdatomic gate (the windows sentinel
+        # surfaced both — the leg rides in the test matrix now)
+        target_compile_options(${target} PRIVATE /W4 /wd4100 /wd4996 /experimental:c11atomics)
+        if(YEPTRIS_WARNINGS_AS_ERRORS)
+            target_compile_options(${target} PRIVATE /WX)
+        endif()
+    else()
+        target_compile_options(${target} PRIVATE -Wall -Wextra -Wno-unused-parameter)
+        if(YEPTRIS_WARNINGS_AS_ERRORS)
+            target_compile_options(${target} PRIVATE -Werror)
+        endif()
+    endif()
+endfunction()
+
+# ------------------------------------------------------------- versioning --
+# CMakeLists project(VERSION) is the single source of truth (TODO.impl/01);
+# scripts/bump-version.sh syncs vcpkg.json and CHANGELOG.md from it.
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/include/yeptris/version.h.in
+    ${CMAKE_BINARY_DIR}/generated/yeptris/version.h
+    @ONLY
+)
+
+# --------------------------------------------------------------- subdirs --
+enable_testing()
+
+add_subdirectory(src)
+
+if(YEPTRIS_BUILD_CLI)
+    add_subdirectory(cli)
+endif()
+
+if(BUILD_TESTING)
+    if(MSVC)
+        add_compile_options(-I${CMAKE_SOURCE_DIR}/test/compat)
+    endif()
+    add_subdirectory(test)
+
+    # Conformance runner (TODO.impl/16): builds on demand; the corpus
+    # arrives via scripts/fetch-corpora.sh.
+    add_executable(test_conformance
+        test/conformance/main.c
+        test/conformance/suite.c
+        test/conformance/tree.c)
+    # Runs in CI after fetch-corpora.sh; passes-as-skip when absent.
+    add_test(NAME conformance
+        COMMAND test_conformance ${CMAKE_SOURCE_DIR}/test/conformance/data/yaml-test-suite/src)
+    # strict: the suite is at 100% — a regression must fail CI, not hide
+    # behind the non-strict exit (a tree-mismatch once slipped through)
+    set_tests_properties(conformance PROPERTIES ENVIRONMENT "YEP_STRICT=1")
+    # psych-pure's parse-{block,flow,scalar,props,stream} corpora,
+    # ported by scripts/port-pure-tml.py (checked-in fixtures)
+    add_test(NAME conformance-pure
+        COMMAND test_conformance ${CMAKE_SOURCE_DIR}/test/conformance/data/psych-pure)
+    set_tests_properties(conformance-pure PROPERTIES ENVIRONMENT "YEP_STRICT=1")
+    target_link_libraries(test_conformance PRIVATE yeptris_static)
+    target_include_directories(test_conformance PRIVATE
+        ${CMAKE_SOURCE_DIR}/src/yeptris
+        ${CMAKE_SOURCE_DIR}/src/include
+        ${CMAKE_BINARY_DIR}/generated)
+    yeptris_set_warnings(test_conformance)
+endif()
+
+if(YEPTRIS_BUILD_BENCHMARKS)
+    add_subdirectory(benchmarks)
+endif()
+
+# --------------------------------------------------------------- install --
+# (TODO.impl/20) targets, headers, pkg-config, and the find_package
+# config; relative paths keep relocatable installs.
+include(GNUInstallDirs)
+
+install(TARGETS yeptris_static
+    EXPORT yeptris-targets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+if(TARGET yeptris_jsonc)
+    install(TARGETS yeptris_jsonc
+        EXPORT yeptris-targets
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    )
+endif()
+if(YEPTRIS_BUILD_CLI AND TARGET yeptris)
+    install(TARGETS yeptris DESTINATION ${CMAKE_INSTALL_BINDIR})
+endif()
+
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src/include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp"
+)
+install(FILES ${CMAKE_BINARY_DIR}/generated/yeptris/version.h
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/yeptris
+)
+
+# pkg-config
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/yeptris.pc.in
+    ${CMAKE_BINARY_DIR}/yeptris.pc @ONLY)
+install(FILES ${CMAKE_BINARY_DIR}/yeptris.pc
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+
+# find_package(yeptris) config
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+    ${CMAKE_BINARY_DIR}/yeptris-config-version.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+install(EXPORT yeptris-targets
+    NAMESPACE yeptris::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/yeptris)
+configure_package_config_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/yeptris-config.cmake.in
+    ${CMAKE_BINARY_DIR}/yeptris-config.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/yeptris)
+install(FILES ${CMAKE_BINARY_DIR}/yeptris-config.cmake
+    ${CMAKE_BINARY_DIR}/yeptris-config-version.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/yeptris)
+

data/vendor/libyeptris/cmake/yeptris-config.cmake.in

@@ -0,0 +1,5 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/yeptris-targets.cmake")
+
+check_required_components(yeptris)

data/vendor/libyeptris/cmake/yeptris.pc.in

@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
+includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
+
+Name: yeptris
+Description: @PROJECT_DESCRIPTION@
+Version: @PROJECT_VERSION@
+URL: https://github.com/leptris/yeptris
+Cflags: -I${includedir}
+Libs: -L${libdir} -lyeptris

data/vendor/libyeptris/src/CMakeLists.txt

@@ -0,0 +1,167 @@
+# libyeptris — core library sources.
+#
+# Subsystems land with their TODO.impl items (common/ 02, memory/ 03,
+# simd/ 04, encoding/ 05, scan/ 06, parse/ 07+). The SIMD per-ISA TUs get
+# their own -m flags here when item 04 lands.
+
+set(YEPTRIS_SOURCES
+    yeptris/version.c
+    yeptris/common/cpu.c
+    yeptris/common/chartype.c
+    yeptris/common/string_view.c
+    yeptris/common/error.c
+    yeptris/common/nametab.c
+    yeptris/common/simd_text.c
+    yeptris/common/simd_text_scalar.c
+    yeptris/memory/allocator.c
+    yeptris/memory/pool.c
+    yeptris/memory/arena.c
+    yeptris/encoding/bom.c
+    yeptris/encoding/transcode.c
+    yeptris/encoding/utf8_validate.c
+    yeptris/scan/json.c
+    yeptris/scan/scan.c
+    yeptris/parse/scalars.c
+    yeptris/parse/engine.c
+    yeptris/dom/dom.c
+    yeptris/dom/hpool.c
+    yeptris/dom/mapindex.c
+    yeptris/dom/mutate.c
+    yeptris/parse.c
+    yeptris/build.c
+    yeptris/events/capture.c
+    yeptris/events/push.c
+    yeptris/events/pull.c
+    yeptris/events/recorder.c
+    yeptris/events/iterparse.c
+    yeptris/events/yaml_compat.c
+    yeptris/resolve/tags.c
+    yeptris/resolve/core12.c
+    yeptris/resolve/compat11.c
+    yeptris/parse/numbers.c
+    yeptris/events/values.c
+    yeptris/schema.c
+    yeptris/tape.c
+    yeptris/plan.c
+
+    yeptris/marshal.c
+    yeptris/visit/json_visit.c
+    yeptris/visit/yaml_visit.c
+    yeptris/visit/dom_visit.c
+    yeptris/emit/style.c
+    yeptris/emit/writer.c
+    yeptris/emit/emit.c
+    yeptris/emit/float/print.c
+    yeptris/emit/float/dragon.c
+)
+
+if(YEPTRIS_WITH_CBOR)
+    list(APPEND YEPTRIS_SOURCES yeptris/cbor/decode.c yeptris/cbor/encode.c)
+endif()
+
+# AOT SIMD TUs (TODO.impl/04): per-ISA compile flags; the TUs and the
+# dispatch share architecture guards, so links resolve on every platform.
+# CMAKE_OSX_ARCHITECTURES participates: an -arch x86_64 cross-build on
+# an arm Mac compiles the dispatch for x86 — the source pick must
+# follow the TARGET arch, not the host (the all-platform wheels ride
+# this; host-processor-only selection linked NEON objects into an
+# x86_64 image).
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|i[3-6]86)$" OR
+    CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
+    list(APPEND YEPTRIS_SOURCES yeptris/common/simd_text_avx2.c)
+    if(MSVC)
+        set_source_files_properties(yeptris/common/simd_text_avx2.c
+            PROPERTIES COMPILE_OPTIONS "/arch:AVX2")
+    else()
+        set_source_files_properties(yeptris/common/simd_text_avx2.c
+            PROPERTIES COMPILE_OPTIONS "-mavx2;-mpopcnt")
+    endif()
+elseif((CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$" OR
+    CMAKE_OSX_ARCHITECTURES MATCHES "arm64") AND NOT CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
+    list(APPEND YEPTRIS_SOURCES yeptris/common/simd_text_neon.c)
+endif()
+
+set(YEPTRIS_PUBLIC_HEADERS
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/api.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/dom.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/error.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/events.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/emit.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/resolve.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/parse.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/values.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/schema.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/tape.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/plan.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/marshal.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/visit.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/json.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/yeptris/types.h
+)
+
+set(YEPTRIS_INCLUDE_DIRS
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated>
+)
+
+# json-c drop-in (TODO.impl/21): REAL json-c symbol names in its own
+# library — users link -lyeptris-jsonc instead of -ljson-c.
+option(YEPTRIS_BUILD_YAJL_COMPAT
+    "Build libyeptris-yajl: the yajl generator drop-in (TODO.impl/21)" ON)
+if(YEPTRIS_BUILD_YAJL_COMPAT AND YEPTRIS_BUILD_STATIC)
+    add_library(yeptris_yajl STATIC yeptris/jsonapi/yajl_compat.c)
+    set_target_properties(yeptris_yajl PROPERTIES OUTPUT_NAME yeptris-yajl)
+    target_link_libraries(yeptris_yajl PUBLIC yeptris_static)
+    target_include_directories(yeptris_yajl PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+    target_include_directories(yeptris_yajl PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris)
+    yeptris_set_warnings(yeptris_yajl)
+    add_library(yeptris::yajl ALIAS yeptris_yajl)
+endif()
+
+if(YEPTRIS_BUILD_JSONC_COMPAT AND YEPTRIS_BUILD_STATIC)
+    add_library(yeptris_jsonc STATIC yeptris/jsonapi/jsonc_compat.c)
+    set_target_properties(yeptris_jsonc PROPERTIES OUTPUT_NAME yeptris-jsonc)
+    target_link_libraries(yeptris_jsonc PUBLIC yeptris_static)
+    target_include_directories(yeptris_jsonc PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+    # internal headers (emit/writer.h, float/api.h): PRIVATE — they
+    # never leak into the compat library's public interface
+    target_include_directories(yeptris_jsonc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris)
+    yeptris_set_warnings(yeptris_jsonc)
+    add_library(yeptris::jsonc ALIAS yeptris_jsonc)
+endif()
+
+if(YEPTRIS_BUILD_STATIC)
+    find_package(Threads REQUIRED)
+
+add_library(yeptris_static STATIC ${YEPTRIS_SOURCES})
+    add_library(yeptris::yeptris ALIAS yeptris_static)
+    set_target_properties(yeptris_static PROPERTIES OUTPUT_NAME yeptris)
+    target_include_directories(yeptris_static
+        PUBLIC ${YEPTRIS_INCLUDE_DIRS}
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris) # internal root-relative includes
+    target_compile_definitions(yeptris_static PRIVATE YEPTRIS_BUILDING)
+    if(YEPTRIS_WITH_CBOR)
+        target_compile_definitions(yeptris_static PUBLIC YEPTRIS_WITH_CBOR)
+    endif()
+    target_link_libraries(yeptris_static PRIVATE Threads::Threads)
+    yeptris_set_warnings(yeptris_static)
+endif()
+
+if(YEPTRIS_BUILD_SHARED)
+    add_library(yeptris_shared SHARED ${YEPTRIS_SOURCES})
+    set_target_properties(yeptris_shared
+        PROPERTIES OUTPUT_NAME yeptris
+                    SOVERSION ${PROJECT_VERSION_MAJOR})
+    target_include_directories(yeptris_shared
+        PUBLIC ${YEPTRIS_INCLUDE_DIRS}
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/yeptris/emit/float)
+    target_compile_definitions(yeptris_shared PRIVATE YEPTRIS_BUILDING)
+    if(YEPTRIS_WITH_CBOR)
+        target_compile_definitions(yeptris_shared PUBLIC YEPTRIS_WITH_CBOR)
+    endif()
+    yeptris_set_warnings(yeptris_shared)
+endif()

data/vendor/libyeptris/src/include/yeptris/api.h

@@ -0,0 +1,32 @@
+/* api.h — export control for libyeptris.
+ *
+ * The library is built with hidden visibility; exactly the YEPTRIS_API-marked
+ * surface is exported. Define YEPTRIS_BUILDING when compiling libyeptris
+ * itself; define YEPTRIS_SHARED when consuming the shared library on Windows.
+ */
+#ifndef YEPTRIS_API_H
+/* YEPTRIS_CT_ASSERT — the compile-time layout gate, C99/MSVC-C-mode/
+ * C++ portable (typedef-array; libleptris's same migration): the old
+ * C11 _Static_assert was the ONE C11 feature pinning the standard. */
+#define YEPTRIS_CT_ASSERT_(cond, line) typedef char yeptris_ct_assert_##line[(cond) ? 1 : -1]
+#define YEPTRIS_CT_ASSERT(cond) YEPTRIS_CT_ASSERT_(cond, __LINE__)
+
+#define YEPTRIS_API_H
+
+#if defined(YEPTRIS_BUILDING) && defined(YEPTRIS_SHARED)
+#error "define YEPTRIS_BUILDING (building) or YEPTRIS_SHARED (consuming), not both"
+#endif
+
+#if defined(YEPTRIS_BUILDING)
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define YEPTRIS_API __declspec(dllexport)
+#else
+#define YEPTRIS_API __attribute__((visibility("default")))
+#endif
+#elif defined(YEPTRIS_SHARED) && (defined(_WIN32) || defined(__CYGWIN__))
+#define YEPTRIS_API __declspec(dllimport)
+#else
+#define YEPTRIS_API
+#endif
+
+#endif /* YEPTRIS_API_H */

data/vendor/libyeptris/src/include/yeptris/cbor.h

@@ -0,0 +1,101 @@
+/* cbor.h — the CBOR (RFC 8949) public surface (TODO.cbor).
+ *
+ * CBOR is the JSON data model in binary: decode builds the same DOM
+ * yeptris_parse_json builds, so every query, emit, and binding API
+ * applies unchanged. The surface compiles only when the library was
+ * built with YEPTRIS_WITH_CBOR (the default). */
+#ifndef YEPTRIS_CBOR_H
+#define YEPTRIS_CBOR_H
+
+#include <stddef.h>
+
+#include <yeptris/api.h>
+#include <yeptris/error.h>
+#include <yeptris/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Flags. */
+#define YEPTRIS_CBOR_STRICT                                                                        \
+    0x1u /* decode: reject non-minimal length                                                      \
+           arguments and non-text-string map keys                                                  \
+           (the deterministic profile's input side) */
+#define YEPTRIS_CBOR_CANONICAL                                                                     \
+    0x2u /* encode: RFC 8949 s4.2.1 core                                                           \
+           deterministic profile — minimal lengths,                                              \
+           definite lengths, preferred floats, map                                                 \
+           keys sorted bytewise on their encoded                                                   \
+           forms (the length-first variant of                                                      \
+           s4.2.3 is NOT selected) */
+
+/* Decodes ONE CBOR data item (RFC 8949). buf must remain valid for the
+ * lifetime of the returned document (string values are borrowed
+ * zero-copy views; indefinite-length chunks concatenate in the
+ * document's arena). Trailing bytes after the item are an error —
+ * CBOR Sequences (RFC 8742) get their own entry point.
+ *
+ * Representation notes (full ledger in src/yeptris/cbor/decode.c):
+ * integers beyond int64 materialize as shortest-double text; bignums
+ * (tags 2/3) stay tag+bytes; byte and text strings are tag-str
+ * scalars; undefined and unassigned simple values are diagnostic text
+ * ("undefined", "simple(N)"); tag chains ride the node's tag field as
+ * a space-separated decimal chain, outermost first.
+ *
+ * On failure returns NULL; *status (may be NULL) receives the code
+ * (YEPTRIS_ERROR_PARSE well-formedness, YEPTRIS_ERROR_ENCODING UTF-8,
+ * YEPTRIS_ERROR_DEPTH nesting, YEPTRIS_ERROR_MEMORY) and
+ * yeptris_last_error() carries the message with the byte offset.
+ *
+ * Memory: the caller owns the document; yeptris_document_free releases
+ * everything in one call. */
+YEPTRIS_API YeptrisDocument yeptris_cbor_decode(const void* buf, size_t len, uint32_t opts,
+                                                YeptrisStatus* status);
+
+/* CBOR Sequences (RFC 8742): top-level data items, concatenated —
+ * no framing bytes. Iterates the buffer, one document per item; the
+ * callback OWNS each item (free it with yeptris_document_free) and
+ * its nonzero return aborts the iteration. Returns the item count
+ * delivered so far. An empty sequence is valid (0 items). A truncated
+ * or malformed trailing item fails YEPTRIS_ERROR_PARSE with the item
+ * index and byte offset on the error channel. opts: decode flags. */
+typedef int (*yeptris_cbor_item_cb)(void* ctx, YeptrisDocument item, size_t index);
+YEPTRIS_API size_t yeptris_cbor_decode_sequence(const void* buf, size_t len, uint32_t opts,
+                                                yeptris_cbor_item_cb cb, void* ctx,
+                                                YeptrisStatus* status);
+
+/* Encodes n documents as a CBOR Sequence: the concatenation of the
+ * items (opts as yeptris_cbor_encode_into). buf == NULL: the exact
+ * byte count. Otherwise writes at most cap and returns the count; a
+ * too-small cap writes nothing and returns the need. Returns 0 on a
+ * NULL items entry or an unencodable document. */
+YEPTRIS_API size_t yeptris_cbor_encode_sequence_into(YeptrisDocument* items, size_t n,
+                                                     uint32_t opts, void* buf, size_t cap);
+
+/* Convenience: the sequence in a malloc'd buffer — caller frees. */
+YEPTRIS_API void* yeptris_cbor_encode_sequence(YeptrisDocument* items, size_t n, uint32_t opts,
+                                               size_t* len);
+
+/* Encodes the document's first root as ONE data item (sequences are a
+ * separate surface). buf == NULL: returns the exact byte count needed.
+ * Otherwise writes at most cap bytes and returns the count written; a
+ * too-small cap writes nothing and returns the needed size. Returns 0
+ * on a NULL document or an unencodable one (aliases, non-decimal tag
+ * text, non-numeric INT/FLOAT text) — yeptris_last_error() says why.
+ *
+ * Canonical opts sort map keys (s4.2.1); without it, insertion order.
+ * encode(decode(x)) is byte-stable across repeated calls. */
+YEPTRIS_API size_t yeptris_cbor_encode_into(YeptrisDocument doc, uint32_t opts, void* buf,
+                                            size_t cap);
+
+/* Convenience: encodes into a malloc'd buffer — caller frees with
+ * free(). Returns NULL on failure; *len (may be NULL) receives the
+ * byte count. */
+YEPTRIS_API void* yeptris_cbor_encode(YeptrisDocument doc, uint32_t opts, size_t* len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEPTRIS_CBOR_H */