yeptris 0.6.7.3-aarch64-linux → 0.6.7.5-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2b1a73208a110633e793944db18644b1c62638deb1371591bc6c9e956fb00b3
-  data.tar.gz: 10d74f98b0969df6236720be0a826b4f15f2c620409d039d9091bde036851760
+  metadata.gz: 0b7d5fc414b1459a5bd7507b2cc3f4dc308efd75010d82f132bd7da078c3e999
+  data.tar.gz: a27ba76d7a111dd8902ff058e1a26cadd05c3cfa921034bcab70bbad48deff0f
 SHA512:
-  metadata.gz: f6a16dac27fcdb4e984d6441118094f85ab72c61bdc9c1fae81dedc523d241a78d3d8e4e53014a8eabda63e56b9219ab27c8b7a27010a4422fc831fb5f639f4e
-  data.tar.gz: f26d6a62827dd6ed440d4e2686137fc18fba15dc954e14fee1d735f5415a9428914e178f24399c63e5693e8e4fe595e4f1165c60f05b2f25896c184f2e68ddb2
+  metadata.gz: 86c23e8e229b87eff443d7e2be1cc16ad57b07a80b8edf5feb7a757e4b611aff34822c78eca5548c72e7eb42a1895f3023b4a50948147e654cb119003ad21a57
+  data.tar.gz: 75ef4719add9a892912352792c0fd8e28347a079ccfee167b1520082d77c1d7a17d83baa593024d2c1b03d8ff0e2d9881f85e6dd1ec56dd00a8606fa25dcaf6f

data/lib/yeptris/cbor.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Yeptris
+  # CBOR (RFC 8949) over the same FFI document the rest of the
+  # binding rides (TODO.cbor/04). Decode materializes through the
+  # Psych-compatible path; encode builds the tree with YAMLTree and
+  # hands the document to the C encoder — plain data only (aliases
+  # and non-decimal tag text are unencodable by the C contract).
+  #
+  # Representation notes inherited from the decoder: integers beyond
+  # int64 and bignums materialize as their shortest-double text, byte
+  # strings as tag-chained text — CBOR's JSON-data-model mapping.
+  module CBOR
+    STRICT = (1 << 0) # decode: reject non-minimal arguments
+    CANONICAL = (1 << 1) # encode: s4.2.1 core deterministic profile
+
+    class Error < Yeptris::Error; end
+    class UnencodableError < Error; end
+
+    module_function
+
+    def available?
+      defined?(::Yeptris::FFI::CBOR_EX) && ::Yeptris::FFI::CBOR_EX
+    end
+
+    def load(data, strict: false)
+      raise Error, "libyeptris has no CBOR support" unless available?
+
+      doc_ptr = ::Yeptris::FFI.yeptris_cbor_decode(data, data.bytesize, strict ? STRICT : 0, nil)
+      raise ParseError, ::Yeptris::FFI.last_error_message if doc_ptr.null?
+
+      # the wrapper's finalizer also frees — its idempotent #free is
+      # the ONLY release path (a raw double free corrupts the heap)
+      doc = ::Yeptris::Document.new(doc_ptr)
+      doc.root.to_ruby
+    ensure
+      doc&.free
+    end
+
+    def load_sequence(data, strict: false)
+      raise Error, "libyeptris has no CBOR support" unless available?
+
+      items = []
+      receiver = ::FFI::Function.new(:int, %i[pointer pointer size_t]) do |_ctx, item, _index|
+        # the callback owns the item; materialize then free in place
+        # (through the wrapper — the finalizer frees too)
+        doc = ::Yeptris::Document.new(item)
+        items << doc.root&.to_ruby
+        doc.free
+        0
+      end
+      st = ::Yeptris::FFI.yeptris_cbor_decode_sequence(
+        data, data.bytesize, strict ? STRICT : 0, receiver, nil, nil
+      )
+      raise ParseError, ::Yeptris::FFI.last_error_message if st.zero? && !data.empty?
+
+      items
+    end
+
+    def dump(obj, canonical: true)
+      docs = build_documents([obj])
+      begin
+        encode_one(docs[0], canonical)
+      ensure
+        docs.each(&:free)
+      end
+    end
+
+    def dump_sequence(objects, canonical: true)
+      docs = build_documents(objects)
+      begin
+        opts = canonical ? CANONICAL : 0
+        arr = ::FFI::MemoryPointer.new(:pointer, docs.size)
+        arr.write_array_of_pointer(docs.map(&:c_ptr))
+        len_ptr = ::FFI::MemoryPointer.new(:size_t)
+        take_buffer(
+          ::Yeptris::FFI.yeptris_cbor_encode_sequence(arr, docs.size, opts, len_ptr),
+          len_ptr
+        )
+      ensure
+        docs.each(&:free)
+      end
+    end
+
+    # -- internals ----------------------------------------------------
+
+    def build_documents(objects)
+      # ONE document per object: a visitor's tree is a single
+      # document and push sets its root — reuse would overwrite
+      objects.map do |obj|
+        visitor = ::Yeptris::Psych::Visitors::YAMLTree.new
+        visitor.push(obj)
+        visitor.document
+      end
+    end
+
+    def encode_one(doc, canonical)
+      opts = canonical ? CANONICAL : 0
+      len_ptr = ::FFI::MemoryPointer.new(:size_t)
+      take_buffer(::Yeptris::FFI.yeptris_cbor_encode(doc.c_ptr, opts, len_ptr), len_ptr)
+    end
+
+    # The encode convenience contract: a malloc'd buffer plus its
+    # byte length — binary data, freed through the library's own free.
+    def take_buffer(ptr, len_ptr)
+      raise UnencodableError, ::Yeptris::FFI.last_error_message if ptr.null?
+
+      len = len_ptr.read_uint64
+      ptr.read_bytes(len).force_encoding(Encoding::BINARY)
+    ensure
+      ::Yeptris::FFI.yeptris_free(ptr) if ptr && !ptr.null?
+    end
+  end
+end

data/lib/yeptris/ffi.rb

@@ -230,17 +230,45 @@ module Yeptris
       false
     end
 
+    # CBOR (RFC 8949, TODO.cbor): absent on libraries before the
+    # codec's release — the CBOR module feature-detects
+    CBOR_EX = begin
+      attach_function :yeptris_cbor_decode, %i[pointer size_t uint32 yeptris_status_out],
+                      :yeptris_document
+      callback :cbor_item_cb, %i[pointer yeptris_document size_t], :int
+      attach_function :yeptris_cbor_decode_sequence,
+                      %i[pointer size_t uint32 cbor_item_cb pointer yeptris_status_out], :size_t
+      attach_function :yeptris_cbor_encode, %i[yeptris_document uint32 pointer], :pointer
+      attach_function :yeptris_cbor_encode_sequence,
+                      %i[pointer size_t uint32 pointer], :pointer
+      true
+    rescue ::FFI::NotFoundError
+      false
+    end
+
     # Owned char* results (serialize*): one reader, freed exactly once.
     # The release goes through yeptris_free (libyeptris's own
     # allocator-matching free) because ffi's :free attach has no
     # Windows process-symbol fallback — libyeptris.dll doesn't export
     # libc free, so resolving :free against it fails on Windows.
-    begin
+    # A raised attach ABORTS this file mid-evaluation — everything
+    # after it (NODE_SCALAR and the kind constants below) never
+    # defines, and a lazily autoloaded node.rb then dies with
+    # 'uninitialized constant' (#138). Every fallback attaches too.
+    YEPTRIS_FREE = begin
       attach_function :yeptris_free, [:pointer], :void
+      :direct
     rescue ::FFI::NotFoundError
-      # libyeptris < v0.6.6: POSIX resolves :free through the process
-      # symbol table, so the direct libc attach still works there.
-      attach_function :yeptris_free, :free, [:pointer], :void
+      begin
+        # libyeptris < v0.6.6: POSIX resolves :free through the
+        # process symbol table, so the libc attach still works there.
+        attach_function :yeptris_free, :free, [:pointer], :void
+        :libc
+      rescue ::FFI::NotFoundError
+        # no owned-buffer release on this lib+platform combination;
+        # Owned.string leaks instead of killing the whole file
+        :none
+      end
     end
 
     module Owned
@@ -258,7 +286,7 @@ module Yeptris
             else
               ptr.read_string.force_encoding(Encoding::UTF_8)
             end
-        ::Yeptris::FFI.yeptris_free(ptr)
+        ::Yeptris::FFI.yeptris_free(ptr) if ::Yeptris::FFI::YEPTRIS_FREE != :none
         s
       end
     end

data/lib/yeptris/psych/visitors.rb

@@ -41,6 +41,12 @@ module Yeptris
           BuiltDocument.new(@tree)
         end
 
+        # The raw document (the CBOR encoder consumes the tree
+        # directly; #tree wraps it for stdlib's yaml face)
+        def document
+          @tree
+        end
+
         def finish
           @tree.serialize(explicit_doc_start: true)
         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.3".freeze
+  VERSION = "0.6.7.5".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
@@ -44,6 +44,7 @@ module Yeptris
   autoload :ValueML, "yeptris/valueml"
   autoload :Psych, "yeptris/psych"
   autoload :Schema, "yeptris/schema"
+  autoload :CBOR, "yeptris/cbor"
 end
 
 # NOTE (the #318 poisoned-process class): the Psych error-name aliases

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()