yeptris 0.6.5.4 → 0.6.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec5a8bfeb0851d4287965e0f7c162cf13b71c90bdbb1f423a2bb0a8f508d22e4
-  data.tar.gz: d757361d8e14a3f94f34419e71334c4c139dc60aaab7aaf638c9dd88239811c5
+  metadata.gz: 802f22f654de443d6a21a15045b6ebea91b025839f7124fb89854e7c90085926
+  data.tar.gz: 3abdcf9d94d0f514c331e4ece6add4d792320fc9f1298a0ff9c9d212581a0f8c
 SHA512:
-  metadata.gz: 75c1451044793867918c6d9972ba7c452d79684c00e7b92a59a30f392bb741fe6c04b6e6571c3c7e6b956c14e7511bd48ba81ab79e552f54675d6726c2dd24d7
-  data.tar.gz: debf5f3377d19dfba238bb412145e7335480dbde4f5c3cff8b8d51aea7426f26038a8913caf1902a92e633684377c52994f10a342e39d2a67a68a5739468ba45
+  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/ffi.rb

@@ -28,17 +28,6 @@ module Yeptris
       MSG
     end
 
-    # :c_free (:free, line ~240) must resolve against the C runtime.
-    # Linux/macOS fall through to the process symbol table, but
-    # Windows has no such fallback — without LIBC attached the
-    # ffi.rb load DIED at that attach (leaving every later constant
-    # undefined: the mingw gem's missing NODE_* / #318).
-    begin
-      ffi_lib FFI::Library::LIBC
-    rescue StandardError
-      # no LIBC handle: the c_free attach below surfaces the failure
-      # exactly where it used to, on non-Windows platforms only
-    end
 
     typedef :pointer, :yeptris_document
     typedef :pointer, :yeptris_node
@@ -242,9 +231,17 @@ module Yeptris
     end
 
     # Owned char* results (serialize*): one reader, freed exactly once.
-    # The buffers are plain malloc'd C memory (the header contract says
-    # "caller frees"), so the release is libc free.
-    attach_function :c_free, :free, [:pointer], :void
+    # 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
+      attach_function :yeptris_free, [:pointer], :void
+    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
+    end
 
     module Owned
       module_function
@@ -261,7 +258,7 @@ module Yeptris
             else
               ptr.read_string.force_encoding(Encoding::UTF_8)
             end
-        ::Yeptris::FFI.c_free(ptr)
+        ::Yeptris::FFI.yeptris_free(ptr)
         s
       end
     end

data/lib/yeptris/json.rb

@@ -71,7 +71,7 @@ module Yeptris
       return s unless s.include?("\\")
 
       b = s.b
-      out = +"".b
+      out = String.new(encoding: Encoding::BINARY)
       i = 0
       n = b.bytesize
       while i < n
@@ -154,7 +154,10 @@ module Yeptris
           stack.pop
           key_sets&.pop
         when T_STR
-          text = lens[i] == 0 ? +"".force_encoding(Encoding::UTF_8) : decode_span(src, offs[i], lens[i])
+          # empty-string literals are frozen+shared since Ruby 3.4
+          # (and `+""` binds after the method chain anyway), so the
+          # fresh copy must come from the encoding call itself
+          text = lens[i] == 0 ? String.new(encoding: Encoding::UTF_8) : decode_span(src, offs[i], lens[i])
           if pending_key.nil? && !stack.empty? && stack.last.is_a?(Hash)
             if key_sets && key_sets.last.key?(text)
               raise ParseError, %(duplicate key "#{text}" in JSON object)

data/lib/yeptris/psych.rb

@@ -4,6 +4,11 @@ require "date"
 require "time"
 require "set"
 
+# Self-sufficient (the #95 yaml.rb fix, same class): the standalone
+# require "yeptris/psych" must register the Document/FFI machinery —
+# consumers load this face directly under the drop-in.
+require "yeptris"
+
 # The Psych drop-in namespace (TODO.impl/15 phase C).
 #
 # `require "yeptris/psych"` loads this namespace WITHOUT touching the
@@ -130,7 +135,7 @@ module Yeptris
       # Psych 5: load is safe — plain data structures only. Tagged
       # nodes raise DisallowedClass unless their class is permitted
       # (Date/Time/Symbol are built in; they are plain data here).
-      def load(yaml, permitted_classes: [], aliases: false, **)
+      def load(yaml, permitted_classes: [::Date, ::Time], aliases: false, **)
         safe_load(yaml, permitted_classes: permitted_classes, aliases: aliases)
       end
 
@@ -144,10 +149,78 @@ module Yeptris
         Visitors::ToRuby.visit(tree.children.first)
       end
 
-      def safe_load(yaml, permitted_classes: [], aliases: false, **)
+      def safe_load(yaml, permitted_classes: [::Date, ::Time], aliases: false, **)
+        doc = Yeptris::Document.parse(yaml, schema: :compat_11)
+        begin
+          force_utf8_scalars(walk_safe(doc.root(0), permitted_classes, aliases))
+        ensure
+          doc.free
+        end
+      end
+
+      # A YAML stream is a Unicode character stream: stdlib psych tags
+      # non-ASCII scalars UTF-8 even when the input String is BINARY
+      # (#135). ASCII-only values keep their (binary) encoding — a
+      # re-tag would be observable there and stdlib does not either.
+      def force_utf8_scalars(obj)
+        case obj
+        when ::String
+          obj.force_encoding(::Encoding::UTF_8) if obj.encoding == ::Encoding::ASCII_8BIT && !obj.ascii_only?
+          obj
+        when ::Hash
+          obj.each { |k, v| force_utf8_scalars(k); force_utf8_scalars(v) }
+        when ::Array
+          obj.each { |v| force_utf8_scalars(v) }
+        else
+          obj
+        end
+      end
+
+      # stdlib's file-level faces (#135): BOM-tolerant UTF-8 reads with
+      # the fallback contract (load_file path, fallback: false default).
+      def load_file(path, fallback: false, **kwargs)
+        File.open(path, "r:bom|utf-8") { |f| load(f, **kwargs) }
+      rescue Errno::ENOENT
+        raise unless fallback
+
+        false
+      end
+
+      def safe_load_file(path, fallback: false, **kwargs)
+        File.open(path, "r:bom|utf-8") { |f| safe_load(f, **kwargs) }
+      rescue Errno::ENOENT
+        raise unless fallback
+
+        false
+      end
+
+      def unsafe_load_file(path, fallback: false, **kwargs)
+        File.open(path, "r:bom|utf-8") { |f| unsafe_load(f, **kwargs) }
+      rescue Errno::ENOENT
+        raise unless fallback
+
+        false
+      end
+
+      def parse_file(path, **kwargs)
+        File.open(path, "r:bom|utf-8") { |f| parse(f, **kwargs) }
+      end
+
+
+
+      # stdlib's deprecated safe/dump split — same output here (every
+      # value this loader produces is safe data)
+      def safe_dump(obj, io = nil, options = {})
+        ::Yeptris::Psych.dump(obj, io, options)
+      end
+
+      def load_stream(yaml, **kwargs)
+        # materialize each document's root directly — the stream
+        # children share one C document, so their handles would all
+        # resolve to the first document's tree
         doc = Yeptris::Document.parse(yaml, schema: :compat_11)
         begin
-          walk_safe(doc.root(0), permitted_classes, aliases)
+          (0...doc.document_count).map { |i| doc.root(i).to_ruby }
         ensure
           doc.free
         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.5.4".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
@@ -44,14 +44,15 @@ module Yeptris
   autoload :ValueML, "yeptris/valueml"
   autoload :Psych, "yeptris/psych"
   autoload :Schema, "yeptris/schema"
-
-  # The safe_load error names, aliased at the top level so consumers
-  # writing rescues need no nesting knowledge (issue #73's naming
-  # note): Yeptris::DisallowedClass is Yeptris::Psych::DisallowedClass.
-  DisallowedClass = Psych::DisallowedClass
-  AliasesError = Psych::AliasesError
 end
 
+# NOTE (the #318 poisoned-process class): the Psych error-name aliases
+# live BELOW the ffi require — reading Psych here would trigger the
+# psych autoload BEFORE the native library resolves, and a mid-load
+# ffi failure under a drop-in rebind left ::Psych rebound against a
+# half-initialized FFI module (every to_yaml in the process died).
+# With this order an ffi failure is a clean, loud require failure.
+
 # Eager native-library resolution (leptris-ruby lesson): fail at
 # require time, not at first parse. The ffi require MUST come after
 # the autoload registrations — ffi.rb opens module Yeptris, and
@@ -67,6 +68,25 @@ rescue LoadError => e
   MSG
 end
 
+
+# The safe_load error names, aliased at the top level so consumers
+# writing rescues need no nesting knowledge (issue #73's naming
+# note): Yeptris::DisallowedClass is Yeptris::Psych::DisallowedClass.
+# LAZY (const_missing): a standalone require "yeptris/psych" loads
+# yeptris.rb MID-psych — an eager alias here would re-enter the
+# half-loaded psych.rb through the autoload and NameError. At first
+# touch psych is complete in every load order.
+module Yeptris
+  def self.const_missing(name)
+    case name
+    when :DisallowedClass, :AliasesError
+      const_set(name, Psych.const_get(name))
+    else
+      super
+    end
+  end
+end
+
 # Optional C-API materializer (TODO.restructure/22): fused visit →
 # Ruby objects via the Ruby C API. Feature-detected — LoadError leaves
 # the FFI ladder (Marshal → columns → records) as the sole path.
@@ -75,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