diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index db3ae81..57b97bc 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -156,5 +156,11 @@ fetch example is prospective, and `CPP_LIBRARY_VERSION=1.0.0` is only a standalo install-validation override, not release evidence. The generated CI runs generic native and clang-tidy presets. -`.github/matrix.json` is not consumed by that workflow; shared, C++17, portable, -ASan, Qt, Emscripten, and package variants need separate validation. +Shared, C++17, portable, ASan, Qt, Emscripten, and package variants need separate +validation. Do not add an unconsumed project matrix or fork the generated workflow. +Toolkit extensions are tracked in stlab/cpp-library#30. + +The pinned cpp-library 5.6.0 release provides the documentation and runtime-DLL +helpers; tests and documentation require no local toolkit override. +Keep Doxygen configuration on the shared toolkit template, declaring project +deltas through `DOCS_INPUTS`, `DOCS_EXCLUDE_SYMBOLS`, and `DOCS_OPTIONS`. diff --git a/.github/matrix.json b/.github/matrix.json deleted file mode 100644 index 713a17e..0000000 --- a/.github/matrix.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "config": [ - { "name": "Linux GCC C++20", "os": "ubuntu-latest", "compiler": "gcc", "preset": "test" }, - { "name": "Linux GCC C++17", "os": "ubuntu-latest", "compiler": "gcc", "preset": "test-cpp17" }, - { "name": "Linux Clang C++20", "os": "ubuntu-latest", "compiler": "clang", "preset": "test" }, - { "name": "Linux shared portable", "os": "ubuntu-latest", "compiler": "gcc", "preset": "test-portable-shared" }, - { "name": "macOS native", "os": "macos-latest", "compiler": "apple-clang", "preset": "test" }, - { "name": "macOS portable", "os": "macos-latest", "compiler": "apple-clang", "preset": "test-portable" }, - { "name": "Windows native static", "os": "windows-latest", "compiler": "Visual Studio", "preset": "test" }, - { "name": "Windows native shared", "os": "windows-latest", "compiler": "Visual Studio", "preset": "test-shared" }, - { "name": "Windows portable shared", "os": "windows-latest", "compiler": "Visual Studio", "preset": "test-portable-shared" }, - { "name": "Linux portable main", "os": "ubuntu-latest", "compiler": "gcc", "preset": "test-portable-main" }, - { "name": "Linux Qt6 main", "os": "ubuntu-latest", "compiler": "gcc", "preset": "test", "qt": "qt6", "cmake_options": "-DSTLAB_MAIN_EXECUTOR=qt6" }, - { "name": "Linux Qt5 main", "os": "ubuntu-latest", "compiler": "gcc", "preset": "test", "qt": "qt5", "cmake_options": "-DSTLAB_MAIN_EXECUTOR=qt5" }, - { "name": "Emscripten pthread", "os": "ubuntu-latest", "compiler": "emscripten", "preset": "test-emscripten" }, - { "name": "Emscripten threadless", "os": "ubuntu-latest", "compiler": "emscripten", "preset": "test-emscripten-threadless" } - ] -} diff --git a/.scout/evaluations/autotune-query-set.toml b/.scout/evaluations/autotune-query-set.toml new file mode 100644 index 0000000..c1fed59 --- /dev/null +++ b/.scout/evaluations/autotune-query-set.toml @@ -0,0 +1,202 @@ +description = "stlab-execution runtime search quality: public adapters, ABI, schedulers, timers, and lifecycle" + +[[queries]] +id = "ident-main-queue" +query = "main_task_queue" +class = "identifier" +[judgments.ident-main-queue] +"src/concurrency/detail/main_task_queue.hpp" = 3 +"src/concurrency/main_executor_portable.cpp" = 2 +"src/concurrency/main_executor_emscripten.cpp" = 2 + +[[queries]] +id = "ident-waiter" +query = "waiter_state" +class = "identifier" +[judgments.ident-waiter] +"src/concurrency/detail/waiter_state.hpp" = 3 +"src/concurrency/executor_abi.cpp" = 2 +"test/waiter_state_test.cpp" = 2 + +[[queries]] +id = "ident-timer-delay" +query = "timer_delay" +class = "identifier" +[judgments.ident-timer-delay] +"src/concurrency/detail/timer_common.hpp" = 3 +"src/concurrency/system_timer_portable.cpp" = 2 +"src/concurrency/system_timer_windows.cpp" = 2 +"src/concurrency/system_timer_libdispatch.cpp" = 2 + +[[queries]] +id = "ident-timer-validation" +query = "check_timer_submission" +class = "identifier" +[judgments.ident-timer-validation] +"src/concurrency/detail/timer_common.hpp" = 3 +"src/concurrency/system_timer_portable.cpp" = 2 +"src/concurrency/system_timer_windows.cpp" = 2 +"src/concurrency/system_timer_emscripten.cpp" = 2 +"src/concurrency/system_timer_libdispatch.cpp" = 2 + +[[queries]] +id = "ident-callback-scope" +query = "core_callback_scope" +class = "identifier" +[judgments.ident-callback-scope] +"src/concurrency/detail/core_shutdown.hpp" = 3 +"src/concurrency/core_shutdown.cpp" = 3 +"src/concurrency/executor_abi.cpp" = 2 +"src/concurrency/system_timer_portable.cpp" = 2 + +[[queries]] +id = "ident-timer-status" +query = "stlab_v2_timer_status" +class = "identifier" +[judgments.ident-timer-status] +"include/stlab/concurrency/system_timer.hpp" = 3 +"src/concurrency/detail/timer_common.hpp" = 2 +"src/concurrency/system_timer_windows.cpp" = 2 +"src/concurrency/system_timer_portable.cpp" = 2 + +[[queries]] +id = "ident-priority" +query = "executor_priority" +class = "identifier" +[judgments.ident-priority] +"include/stlab/concurrency/default_executor.hpp" = 3 +"src/concurrency/executor_abi.cpp" = 2 + +[[queries]] +id = "ident-pre-exit" +query = "pre_exit" +class = "identifier" +[judgments.ident-pre-exit] +"include/stlab/pre_exit.hpp" = 3 +"src/pre_exit.cpp" = 3 +"src/concurrency/core_shutdown.cpp" = 2 + +[[queries]] +id = "nl-retirement-order" +query = "how does shutdown cancel pending timers before draining executor tasks" +class = "natural_language" +[judgments.nl-retirement-order] +"src/concurrency/core_shutdown.cpp" = 3 +"src/concurrency/detail/core_shutdown.hpp" = 2 +"src/concurrency/system_timer_portable.cpp" = 2 +"src/concurrency/system_timer_windows.cpp" = 2 +"src/concurrency/cooperative_executor.cpp" = 2 +"test/system_timer_executor_shutdown.cpp" = 2 +"src/pre_exit.cpp" = 1 + +[[queries]] +id = "nl-task-storage" +query = "move-only callable small buffer storage and nonthrowing relocation" +class = "natural_language" +[judgments.nl-task-storage] +"include/stlab/concurrency/task.hpp" = 3 +"include/stlab/concurrency/default_executor.hpp" = 2 +"src/concurrency/detail/main_task_queue.hpp" = 1 +"src/concurrency/executor_abi.cpp" = 1 + +[[queries]] +id = "nl-cooperative-drain" +query = "threadless cooperative executor keeps event loop responsive while retiring descendants" +class = "natural_language" +[judgments.nl-cooperative-drain] +"src/concurrency/cooperative_executor.cpp" = 3 +"src/concurrency/main_executor_emscripten.cpp" = 2 +"src/concurrency/detail/core_shutdown.hpp" = 2 +"include/stlab/pre_exit.hpp" = 2 +"src/concurrency/core_shutdown.cpp" = 1 + +[[queries]] +id = "nl-lost-wake" +query = "remember a worker wake request that arrives before it starts waiting" +class = "natural_language" +[judgments.nl-lost-wake] +"src/concurrency/detail/waiter_state.hpp" = 3 +"src/concurrency/executor_abi.cpp" = 2 +"test/waiter_state_test.cpp" = 2 + +[[queries]] +id = "nl-timer-rounding" +query = "round positive timer delays upward and recheck monotonic time to prevent early callbacks" +class = "natural_language" +[judgments.nl-timer-rounding] +"include/stlab/concurrency/system_timer.hpp" = 3 +"src/concurrency/detail/timer_common.hpp" = 3 +"src/concurrency/system_timer_portable.cpp" = 2 +"src/concurrency/system_timer_windows.cpp" = 2 +"src/concurrency/system_timer_libdispatch.cpp" = 2 + +[[queries]] +id = "nl-main-fifo" +query = "main executor FIFO queue waits for work and invokes callbacks outside the queue mutex" +class = "natural_language" +[judgments.nl-main-fifo] +"src/concurrency/detail/main_task_queue.hpp" = 3 +"src/concurrency/main_executor_portable.cpp" = 3 +"src/concurrency/main_executor_emscripten.cpp" = 2 +"src/concurrency/main_executor_libdispatch.cpp" = 2 + +[[queries]] +id = "nl-callback-shutdown" +query = "reject synchronous shutdown from a native timer or executor callback including capture destruction" +class = "natural_language" +[judgments.nl-callback-shutdown] +"src/concurrency/core_shutdown.cpp" = 3 +"src/concurrency/detail/core_shutdown.hpp" = 2 +"src/pre_exit.cpp" = 2 +"src/concurrency/system_timer_portable.cpp" = 1 +"src/concurrency/executor_abi.cpp" = 1 + +[[queries]] +id = "filt-public-status" +query = "stlab_v2_timer_status" +class = "filtered" +extensions = ["hpp"] +paths = ["include/stlab"] +[judgments.filt-public-status] +"include/stlab/concurrency/system_timer.hpp" = 3 + +[[queries]] +id = "filt-detail-waiter" +query = "waiter_state" +class = "filtered" +extensions = ["hpp"] +paths = ["src/concurrency/detail"] +[judgments.filt-detail-waiter] +"src/concurrency/detail/waiter_state.hpp" = 3 + +[[queries]] +id = "filt-priority" +query = "executor_priority" +class = "filtered" +extensions = ["hpp"] +paths = ["include/stlab/concurrency"] +[judgments.filt-priority] +"include/stlab/concurrency/default_executor.hpp" = 3 + +[[queries]] +id = "filt-monotonic-delay" +query = "timer_delay" +class = "filtered" +extensions = ["hpp"] +paths = ["src/concurrency/detail"] +[judgments.filt-monotonic-delay] +"src/concurrency/detail/timer_common.hpp" = 3 + +[[queries]] +id = "filt-callback-guard" +query = "core_callback_scope" +class = "filtered" +extensions = ["cpp"] +paths = ["src/concurrency"] +[judgments.filt-callback-guard] +"src/concurrency/core_shutdown.cpp" = 3 +"src/concurrency/executor_abi.cpp" = 2 +"src/concurrency/system_timer_windows.cpp" = 2 +"src/concurrency/system_timer_portable.cpp" = 2 +"src/concurrency/system_timer_libdispatch.cpp" = 2 +"src/concurrency/system_timer_emscripten.cpp" = 2 diff --git a/.scout/memory/index.md b/.scout/memory/index.md new file mode 100644 index 0000000..4dd1e0d --- /dev/null +++ b/.scout/memory/index.md @@ -0,0 +1,17 @@ +# Memory Bank Index + +## Knowledge + +- [[knowledge/abi-stability-version-namespaces-and-shared-library-exports.md|ABI Stability, Version Namespaces, and Shared Library Exports]] (decision, 0.80) `abi-stability` `version-namespaces` `execution-def` `task-abi-guard` `shared-library-abi` +- [[knowledge/architecture-overview.md|Architecture Overview]] (concept, 0.80) `architecture-overview` `stlab-execution` `execution-runtime` `concurrency-runtime` `stlab-concurrency` +- [[knowledge/concurrency-contracts-and-locking-discipline.md|Concurrency Contracts and Locking Discipline]] (pattern, 0.80) `concurrency-contracts` `locking-rules` `synchronization-invariants` `mutex-discipline` `lock-scoping` +- [[knowledge/executor-architecture-and-native-priority-schedulers.md|Executor Architecture and Native Priority Schedulers]] (concept, 0.75) `default-executor` `executor-abi` `priority-task-system` `thread-pool` `stlab-v2-default-executor-submit` +- [[knowledge/main-executor-backends-and-dispatch-queue.md|Main Executor Backends and Dispatch Queue]] (concept, 0.75) `main-executor` `main-task-queue` `main-queue` `portable-main-executor` +- [[knowledge/process-lifecycle-and-pre-exit-protocol.md|Process Lifecycle and Pre-Exit Protocol]] (decision, 0.80) `pre-exit` `at-pre-exit` `process-shutdown` `stlab-pre-exit` `core-shutdown` +- [[knowledge/system-timer-architecture-and-guarantees.md|System Timer Architecture and Guarantees]] (concept, 0.75) `system-timer` `timer-status` `stlab-v2-system-timer-submit` `timer-delay` `portable-timers` +- [[knowledge/task-type-erasure-and-relocation-abi.md|Task Type Erasure and Relocation ABI]] (concept, 0.80) `task` `task-t` `stlab-v2-task-concept` `type-erasure` `move-only-task` +- [[knowledge/threadless-emscripten-cooperative-execution-and-shutdown.md|Threadless Emscripten Cooperative Execution and Shutdown]] (concept, 0.75) `emscripten` `cooperative-executor` `threadless-wasm` `webassembly-execution` `wasm-pre-exit` + +## Procedures + +- [[procedures/build-presets-testing-matrix-and-cpp-library-tooling.md|Build Presets, Testing Matrix, and cpp-library Tooling]] (procedure, 0.80) `build-system` `cmake-presets` `cpp-library` `test-infrastructure` `ctest-matrix` diff --git a/.scout/memory/knowledge/abi-stability-version-namespaces-and-shared-library-exports.md b/.scout/memory/knowledge/abi-stability-version-namespaces-and-shared-library-exports.md new file mode 100644 index 0000000..cf28da4 --- /dev/null +++ b/.scout/memory/knowledge/abi-stability-version-namespaces-and-shared-library-exports.md @@ -0,0 +1,34 @@ +--- +title: "ABI Stability, Version Namespaces, and Shared Library Exports" +entity_type: decision +confidence: 0.80 +created: 2026-10-13T00:39:46Z +last_accessed: 2026-10-13T00:39:46Z +last_reinforced: 2026-10-13T00:39:46Z +access_count: 1 +sources: + - "include/stlab/concurrency/task.hpp:60-80" + - "include/stlab/concurrency/default_executor.hpp:50-80" + - "src/execution.def:1-30" + - "CMakeLists.txt:1-60" +relationships: + - type: relates_to + target: "Architecture Overview" + - type: relates_to + target: "Task Type Erasure and Relocation ABI" +tags: ["abi-stability", "version-namespaces", "execution-def", "task-abi-guard", "shared-library-abi"] +tier: knowledge +source: inferred +--- + +# ABI Stability, Version Namespaces, and Shared Library Exports + +`stlab-execution` employs versioned symbols and ABI namespaces to prevent symbol collisions and preserve binary compatibility across component updates: + +Key rules and constraints: +1. Version namespaces: C++ interfaces live inside `STLAB_EXECUTION_VERSION_NAMESPACE_BEGIN()` and `END()`, which expand to versioned inline namespaces (`inline namespace v2`). Internal implementation helpers reside in `execution_detail`. +2. Linker ABI Guard: Task submission across the C boundary requires passing `task_abi_guard` pointing to `execution_detail::current_task_storage_abi_guard::value`. Any mismatch in SBO buffer layout, alignment, or calling convention causes immediate assertion failure and termination. +3. C Export Vector: Core functions are exposed as C entry points (`stlab_pre_exit`, `stlab_at_pre_exit`, `stlab_v2_default_executor_submit`, etc.) and explicitly tracked in `src/execution.def` on Windows DLL builds. ABI changes require defining new versioned entry points, not weakening layout assertions. +4. Header generation: Platform capabilities are generated into `stlab/execution/config.hpp` via `config.hpp.in` and CMake. Never edit `config.hpp` directly in the build tree. + +Aliases / also known as: abi_stability, version_namespaces, execution_def, task_abi_guard, shared_library_abi diff --git a/.scout/memory/knowledge/architecture-overview.md b/.scout/memory/knowledge/architecture-overview.md new file mode 100644 index 0000000..b2182c3 --- /dev/null +++ b/.scout/memory/knowledge/architecture-overview.md @@ -0,0 +1,29 @@ +--- +title: "Architecture Overview" +entity_type: concept +confidence: 0.80 +created: 2026-10-13T00:38:31Z +last_accessed: 2026-10-13T00:38:31Z +last_reinforced: 2026-10-13T00:38:31Z +access_count: 1 +sources: + - "README.md:1-40" + - "include/stlab/concurrency/task.hpp:12-32" + - "include/stlab/pre_exit.hpp:11-32" +tags: ["architecture-overview", "stlab-execution", "execution-runtime", "concurrency-runtime", "stlab-concurrency"] +tier: knowledge +source: inferred +--- + +# Architecture Overview + +stlab-execution is the standalone C++17/20 execution runtime extracted from STLab, providing move-only tasks, priority executors, asynchronous timers, and process lifecycle coordination (`pre_exit()`). It preserves canonical stlab namespace and include paths (``, ``), but deliberately excludes futures, channels, serial queues, and coroutine policies (which reside in higher-level libraries). Public C++ interfaces are header-only inline templates, while compiled sources implement process-wide schedulers, thread pools, and lifecycle state. + +First-to-read headers and entry points: +- `include/stlab/concurrency/task.hpp`: non-copyable type-erased callable wrapper with SBO and noexcept relocation across the C ABI. +- `include/stlab/concurrency/default_executor.hpp`: default, high, and low priority thread-pool executors. +- `include/stlab/concurrency/system_timer.hpp`: non-early asynchronous timer service. +- `include/stlab/pre_exit.hpp`: process-wide LIFO pre-exit handler registry and drain barrier. +- `src/concurrency/executor_abi.cpp`: ABI implementation for native priority queues, threadpool backends, and portable blocking compensation. + +Aliases / also known as: architecture_overview, stlab_execution, execution_runtime, concurrency_runtime, stlab_concurrency diff --git a/.scout/memory/knowledge/concurrency-contracts-and-locking-discipline.md b/.scout/memory/knowledge/concurrency-contracts-and-locking-discipline.md new file mode 100644 index 0000000..4c8f1e9 --- /dev/null +++ b/.scout/memory/knowledge/concurrency-contracts-and-locking-discipline.md @@ -0,0 +1,33 @@ +--- +title: "Concurrency Contracts and Locking Discipline" +entity_type: pattern +confidence: 0.80 +created: 2026-10-13T00:39:55Z +last_accessed: 2026-10-13T00:39:55Z +last_reinforced: 2026-10-13T00:39:55Z +access_count: 1 +sources: + - "CLAUDE.md:1-50" + - "src/concurrency/detail/main_task_queue.hpp:25-55" + - "src/concurrency/core_shutdown.cpp:30-80" +relationships: + - type: relates_to + target: "Architecture Overview" + - type: relates_to + target: "Task Type Erasure and Relocation ABI" +tags: ["concurrency-contracts", "locking-rules", "synchronization-invariants", "mutex-discipline", "lock-scoping"] +tier: knowledge +source: inferred +--- + +# Concurrency Contracts and Locking Discipline + +Strict concurrency and lock-scoping guidelines govern all internal synchronization within `stlab-execution`: + +Key rules and invariants: +1. Narrowest lock scope: Mutexes must protect only the minimal shared state invariant. Callbacks, capture destruction, task bodies, user code, and blocking waits must NEVER be executed inside a mutex critical section. +2. Mandatory mutex documentation: Every mutex declaration in source code must include a comment detailing the exact state and synchronization invariant it protects, including any associated condition variable coordination. +3. Queue push/pop safety: Callable construction, copy/move construction, and moved-from object destruction are prohibited from submitting work to queues, because queue implementations may hold locks during element relocation or destruction. +4. Mutex vs Atomic: Protect a single primitive with `std::atomic` only if compound invariants, wait queues, or object lifetime guarantees are not required. + +Aliases / also known as: concurrency_contracts, locking_rules, synchronization_invariants, mutex_discipline, lock_scoping diff --git a/.scout/memory/knowledge/executor-architecture-and-native-priority-schedulers.md b/.scout/memory/knowledge/executor-architecture-and-native-priority-schedulers.md new file mode 100644 index 0000000..910a172 --- /dev/null +++ b/.scout/memory/knowledge/executor-architecture-and-native-priority-schedulers.md @@ -0,0 +1,35 @@ +--- +title: "Executor Architecture and Native Priority Schedulers" +entity_type: concept +confidence: 0.75 +created: 2026-10-13T00:39:05Z +last_accessed: 2026-10-13T00:39:05Z +last_reinforced: 2026-10-13T00:39:05Z +access_count: 1 +sources: + - "include/stlab/concurrency/default_executor.hpp:50-115" + - "src/concurrency/executor_abi.cpp:630-760" +relationships: + - type: depends_on + target: "Task Type Erasure and Relocation ABI" + - type: relates_to + target: "Process Lifecycle and Pre-Exit Protocol" +tags: ["default-executor", "executor-abi", "priority-task-system", "thread-pool", "stlab-v2-default-executor-submit"] +tier: knowledge +source: inferred +--- + +# Executor Architecture and Native Priority Schedulers + +Default thread-pool executors submit tasks through an ABI-stable C interface (`stlab_v2_default_executor_submit`, `stlab_v2_high_executor_submit`, `stlab_v2_low_executor_submit`) defined in `include/stlab/concurrency/default_executor.hpp`. + +Key mechanics: +1. Entry points take a `task_abi_guard` pointer (`current_task_storage_abi_guard::value`), a vtable pointer (`stlab_v2_task_concept`), an invocation procedure (`stlab_v2_task_proc`), and a relocation source pointer. +2. Backends: In `src/concurrency/executor_abi.cpp`, native priority scheduling is sharded. Backends are selected at build time: + - macOS/Apple: Apple libdispatch (GCD) global concurrent queues (`DISPATCH_QUEUE_PRIORITY_*`). + - Windows: Windows thread pool APIs (`TrySubmitThreadpoolCallback`). + - Portable: Native portable worker threads (`priority_task_system`). + - Threadless Emscripten: `cooperative_executor.cpp` using the browser/Node event loop. +3. Blocking-wait compensation: Portable executor provides `stlab_v2_notify_default_executor_before_waiting()` (`stlab_v2_default_executor_supports_blocking()`). Calling threads notify the scheduler before blocking, allowing the thread pool to spawn a temporary worker thread to maintain concurrency and avoid deadlocks. On OS-managed pools (Windows/libdispatch), this is a no-op. + +Aliases / also known as: default_executor, executor_abi, priority_task_system, thread_pool, stlab_v2_default_executor_submit diff --git a/.scout/memory/knowledge/main-executor-backends-and-dispatch-queue.md b/.scout/memory/knowledge/main-executor-backends-and-dispatch-queue.md new file mode 100644 index 0000000..a7375e0 --- /dev/null +++ b/.scout/memory/knowledge/main-executor-backends-and-dispatch-queue.md @@ -0,0 +1,33 @@ +--- +title: "Main Executor Backends and Dispatch Queue" +entity_type: concept +confidence: 0.75 +created: 2026-10-13T00:39:25Z +last_accessed: 2026-10-13T00:39:25Z +last_reinforced: 2026-10-13T00:39:25Z +access_count: 1 +sources: + - "cmake/ExecutionPlatform.cmake:52-67" + - "src/concurrency/detail/main_task_queue.hpp:20-55" + - "src/concurrency/main_executor_none.cpp:1-25" +relationships: + - type: relates_to + target: "Architecture Overview" + - type: relates_to + target: "Process Lifecycle and Pre-Exit Protocol" +tags: ["main-executor", "main-task-queue", "main-queue", "portable-main-executor"] +tier: knowledge +source: inferred +--- + +# Main Executor Backends and Dispatch Queue + +Main-queue execution and task systems are orthogonal platform selections in CMake (`cmake/ExecutionPlatform.cmake` and `cmake/ExecutionConfig.cmake`). + +Key mechanics: +1. Selection independent of task system: `STLAB_MAIN_EXECUTOR` can be configured as `qt5`, `qt6`, `libdispatch`, `emscripten`, `portable`, or `none`. On Windows and desktop Linux without Qt or GCD, it defaults to `none`. +2. `main_task_queue`: When `portable` or Qt/libdispatch main execution is active, `main_task_queue` (`src/concurrency/detail/main_task_queue.hpp`) manages FIFO task queuing using a mutex and condition variable. +3. Teardown independence: Main executor admission remains open even during `shutdown_core()`. Core teardown drains default/high/low executors and cancels timers, but does not close main-queue admission, allowing main tasks to coordinate shutdown or UI teardown. +4. Main thread fence: Producers joined during shutdown must not synchronously depend on main-queue progress, or deadlocks will occur if `pre_exit()` was called from the main thread. + +Aliases / also known as: main_executor, main_task_queue, main_queue, portable_main_executor diff --git a/.scout/memory/knowledge/process-lifecycle-and-pre-exit-protocol.md b/.scout/memory/knowledge/process-lifecycle-and-pre-exit-protocol.md new file mode 100644 index 0000000..5c2d9f8 --- /dev/null +++ b/.scout/memory/knowledge/process-lifecycle-and-pre-exit-protocol.md @@ -0,0 +1,34 @@ +--- +title: "Process Lifecycle and Pre-Exit Protocol" +entity_type: decision +confidence: 0.80 +created: 2026-10-13T00:38:46Z +last_accessed: 2026-10-13T00:40:29Z +last_reinforced: 2026-10-13T00:38:46Z +access_count: 2 +sources: + - "include/stlab/pre_exit.hpp:11-32" + - "include/stlab/pre_exit.hpp:59-74" + - "src/pre_exit.cpp:38-90" + - "src/concurrency/core_shutdown.cpp:48-102" +relationships: + - type: relates_to + target: "Architecture Overview" +tags: ["pre-exit", "at-pre-exit", "process-shutdown", "stlab-pre-exit", "core-shutdown"] +tier: knowledge +source: inferred +--- + +# Process Lifecycle and Pre-Exit Protocol + +`stlab::pre_exit()` manages process lifecycle by running registered handlers in reverse registration order (LIFO). Registration via `stlab::at_pre_exit()` accepts `void (*)() noexcept` functions. + +Crucial synchronization and ordering invariants: +1. `pre_exit()` must be invoked exactly once before normal termination (prior to `exit()` or leaving `main()`). +2. Core teardown handler (`shutdown_core()` in `src/concurrency/core_shutdown.cpp`) is lazily registered upon first use of default executors or system timers. +3. Applications that need running worker tasks or timer callbacks to finish must register unblocking handlers *after* first core use, so LIFO execution runs application teardown before core teardown. +4. Core teardown cancels pending timers, waits for committed timer callbacks, then drains initialized default executors. +5. In threaded builds, default/high/low executor tasks and timer callbacks (including executed-target destructors) are strictly prohibited from calling `pre_exit()`. Violations terminate immediately via `check_pre_exit_context()`. +6. On threadless Emscripten, `pre_exit()` does not block; it initiates asynchronous cooperative retirement. A main task submitted after `pre_exit()` serves as the completion fence. + +Aliases / also known as: pre_exit, at_pre_exit, process_shutdown, stlab_pre_exit, core_shutdown diff --git a/.scout/memory/knowledge/system-timer-architecture-and-guarantees.md b/.scout/memory/knowledge/system-timer-architecture-and-guarantees.md new file mode 100644 index 0000000..d0dd24c --- /dev/null +++ b/.scout/memory/knowledge/system-timer-architecture-and-guarantees.md @@ -0,0 +1,33 @@ +--- +title: "System Timer Architecture and Guarantees" +entity_type: concept +confidence: 0.75 +created: 2026-10-13T00:39:14Z +last_accessed: 2026-10-13T00:40:36Z +last_reinforced: 2026-10-13T00:39:14Z +access_count: 2 +sources: + - "include/stlab/concurrency/system_timer.hpp:50-80" + - "src/concurrency/detail/timer_common.hpp:25-70" + - "src/concurrency/system_timer_portable.cpp:90-125" +relationships: + - type: relates_to + target: "Process Lifecycle and Pre-Exit Protocol" + - type: depends_on + target: "Task Type Erasure and Relocation ABI" +tags: ["system-timer", "timer-status", "stlab-v2-system-timer-submit", "timer-delay", "portable-timers"] +tier: knowledge +source: inferred +--- + +# System Timer Architecture and Guarantees + +The system timer service (`include/stlab/concurrency/system_timer.hpp`) schedules asynchronous tasks for future execution with explicit duration guarantees. + +Key invariants and operational rules: +1. Non-early execution guarantee: Positive delays round upward in nanoseconds (`timer_integral_nanoseconds()`) and are guaranteed never to fire prematurely. Non-positive delays are treated as asynchronous zero-delay submissions. +2. ABI-level error protocol: `stlab_v2_system_timer_submit` returns standard-layout `stlab_v2_timer_status` (0=success, 1=allocation failure, 2=generic_category, 3=system_category). Submission failure leaves the source task unconsumed; successful submission assumes exactly-once execution or cancellation. +3. Teardown & cancellation: System timer registers with `core_shutdown` on first use. During `pre_exit()`, pending timers are canceled immediately and their captured state is destroyed; running timer callbacks are waited on (joined) before executor drain begins. +4. Threaded restriction: Timer callbacks and their capture destructors must never invoke `pre_exit()`. + +Aliases / also known as: system_timer, timer_status, stlab_v2_system_timer_submit, timer_delay, portable_timers diff --git a/.scout/memory/knowledge/task-type-erasure-and-relocation-abi.md b/.scout/memory/knowledge/task-type-erasure-and-relocation-abi.md new file mode 100644 index 0000000..da579c7 --- /dev/null +++ b/.scout/memory/knowledge/task-type-erasure-and-relocation-abi.md @@ -0,0 +1,31 @@ +--- +title: "Task Type Erasure and Relocation ABI" +entity_type: concept +confidence: 0.80 +created: 2026-10-13T00:38:55Z +last_accessed: 2026-10-13T00:38:55Z +last_reinforced: 2026-10-13T00:38:55Z +access_count: 1 +sources: + - "include/stlab/concurrency/task.hpp:12-32" + - "include/stlab/concurrency/task.hpp:63-80" + - "include/stlab/concurrency/task.hpp:160-200" +relationships: + - type: relates_to + target: "Architecture Overview" +tags: ["task", "task-t", "stlab-v2-task-concept", "type-erasure", "move-only-task"] +tier: knowledge +source: inferred +--- + +# Task Type Erasure and Relocation ABI + +`stlab::task` provides a move-only type-erased callable wrapper (similar to `std::function`, but non-copyable). It is explicitly designed for move-only and single-shot targets in executor queues. + +Key invariants and contracts: +1. Non-throwing relocation across ABI: Small callables with non-throwing move constructors are stored in a small-buffer optimization (SBO) buffer (`stlab_v2_task_storage_size`), while larger or throwing callables are heap-allocated. Relocation across the C ABI is guaranteed non-throwing via `stlab_v2_task_concept` operation tables. +2. Queued-target lifecycle requirement: Callable construction, copy/move construction, and destruction of moved-from callables must NOT submit work to executors or timers, because queues may perform relocation/destruction while holding internal locks. +3. Invocation & destruction: Task invocation and destruction of executed targets ARE permitted to submit work while admission is open. +4. Empty tasks: An empty task compares equal to `nullptr`. Invoking an empty task throws `std::bad_function_call` for throwing signatures, or calls `std::terminate()` for `noexcept` signatures. + +Aliases / also known as: task, task_t, stlab_v2_task_concept, type_erasure, move_only_task diff --git a/.scout/memory/knowledge/threadless-emscripten-cooperative-execution-and-shutdown.md b/.scout/memory/knowledge/threadless-emscripten-cooperative-execution-and-shutdown.md new file mode 100644 index 0000000..a7ad1af --- /dev/null +++ b/.scout/memory/knowledge/threadless-emscripten-cooperative-execution-and-shutdown.md @@ -0,0 +1,33 @@ +--- +title: "Threadless Emscripten Cooperative Execution and Shutdown" +entity_type: concept +confidence: 0.75 +created: 2026-10-13T00:39:36Z +last_accessed: 2026-10-13T00:39:36Z +last_reinforced: 2026-10-13T00:39:36Z +access_count: 1 +sources: + - "src/pre_exit.cpp:25-58" + - "src/concurrency/detail/cooperative_executor.hpp:20-60" + - "src/concurrency/cooperative_executor.cpp:1-50" +relationships: + - type: relates_to + target: "Process Lifecycle and Pre-Exit Protocol" + - type: relates_to + target: "Executor Architecture and Native Priority Schedulers" +tags: ["emscripten", "cooperative-executor", "threadless-wasm", "webassembly-execution", "wasm-pre-exit"] +tier: knowledge +source: inferred +--- + +# Threadless Emscripten Cooperative Execution and Shutdown + +Threadless Emscripten (WebAssembly without pthreads) operates in a single-threaded environment with run-to-completion semantics, requiring specialized execution handling: + +Key architectural distinctions: +1. `cooperative_executor`: Implemented in `src/concurrency/cooperative_executor.cpp` and `detail/cooperative_executor.hpp`. Instead of background threads, tasks yield control back to the host event loop via microtasks or `setTimeout`. +2. Blocking prohibition: Blocking operations (e.g. `wait()`, `std::condition_variable::wait()`, sleeping) are strictly impossible and unsupported. +3. Pre-exit behavior: `pre_exit()` cannot block to join threads. Instead, it initiates asynchronous retirement (`phase::deferred` in `src/pre_exit.cpp`). Remaining pre-exit handlers and ordinary main tasks are deferred until queued cooperative executor tasks and descendant tasks drain completely. +4. Completion fence: An ordinary main task queued *after* `pre_exit()` acts as the final completion fence; final process exit must wait for that fence to execute. + +Aliases / also known as: emscripten, cooperative_executor, threadless_wasm, webassembly_execution, wasm_pre_exit diff --git a/.scout/memory/procedures/build-presets-testing-matrix-and-cpp-library-tooling.md b/.scout/memory/procedures/build-presets-testing-matrix-and-cpp-library-tooling.md new file mode 100644 index 0000000..320719b --- /dev/null +++ b/.scout/memory/procedures/build-presets-testing-matrix-and-cpp-library-tooling.md @@ -0,0 +1,35 @@ +--- +title: "Build Presets, Testing Matrix, and cpp-library Tooling" +entity_type: procedure +confidence: 0.80 +created: 2026-10-13T00:40:05Z +last_accessed: 2026-10-13T00:40:05Z +last_reinforced: 2026-10-13T00:40:05Z +access_count: 1 +sources: + - "CMakePresets.json:1-100" + - "README.md:30-85" + - "CLAUDE.md:20-60" +relationships: + - type: relates_to + target: "Architecture Overview" +tags: ["build-system", "cmake-presets", "cpp-library", "test-infrastructure", "ctest-matrix"] +tier: procedures +source: inferred +--- + +# Build Presets, Testing Matrix, and cpp-library Tooling + +`stlab-execution` uses standard CMake presets and pins `cpp-library` for build orchestration, packaging, and CI workflows: + +Key infrastructure rules: +1. Pinned dependency `cpp-library`: Uses `cpp-library` pinned via CPM (e.g. v5.6.0 on branch `prepare-v1-0-0-release`). Files marked auto-generated (CI workflows, `.clang-format`, etc.) must not be edited directly; they are updated via `cmake --preset=init && cmake --build --preset=init`. +2. Standard presets: + - `default`: Library-only release build. + - `test`: Complete debug build and test suite (`ctest --preset=test`). + - `clang-tidy`: Static analysis with project `.clang-tidy`. + - `docs`: API reference generation via Doxygen. +3. Test layout: Core tests use doctest (`execution.test.task`, `execution.test.executor`, `execution.test.system_timer`, etc.). Lifecycle and failure scenarios run as isolated CTest processes with explicit timeouts to test termination behavior safely. +4. Language standards: Defaults to C++20 for compilation, but all public interfaces must strictly retain compatibility with C++17 consumers. + +Aliases / also known as: build_system, cmake_presets, cpp_library, test_infrastructure, ctest_matrix diff --git a/.scout/memory/schema.md b/.scout/memory/schema.md new file mode 100644 index 0000000..1d4d2a1 --- /dev/null +++ b/.scout/memory/schema.md @@ -0,0 +1,54 @@ +--- +title: Memory Bank Schema +--- + +# Entity Types + +| Type | Description | Default Confidence | Default Tier | Decay Rate | +|------|-------------|-------------------|-------------|------------| +| observation | Raw finding from a session | 0.5 | working | 0.95/day | +| episode | Session summary, compressed from observations | 0.6 | episodes | 0.98/day | +| discovery | Verified insight about the codebase | 0.7 | knowledge | 0.995/day | +| decision | Architectural or design choice | 0.7 | knowledge | 0.995/day | +| pattern | Recurring code or process pattern | 0.8 | knowledge | 0.995/day | +| procedure | Step-by-step workflow | 0.8 | procedures | 0.999/day | +| person | Team member with role/expertise | 0.9 | peers | 0.999/day | +| project | Initiative or workstream | 0.7 | knowledge | 0.98/day | +| concept | Domain concept or term | 0.9 | knowledge | 0.999/day | + +# Relationship Types + +| Type | Meaning | Edge Category | +|------|---------|--------------| +| caused_by | X was caused by Y | import | +| supersedes | X replaces Y (target confidence drops) | import | +| contradicts | X conflicts with Y (flagged for resolution) | import | +| applies_to | X is relevant to Y | call | +| owned_by | X is owned/championed by Y | type_ref | +| depends_on | X requires Y | import | +| fixed_by | X was resolved by Y | call | +| consolidated_into | X was merged into Y during consolidation | import | +| relates_to | General association between X and Y | call | +| extends | X builds on or adds detail to Y | import | +| implements | X is a concrete realization of Y | import | +| requires | X operationally depends on Y (tool, service) | import | + +# Consolidation Rules + +| Transition | Trigger | Action | +|-----------|---------|--------| +| working -> episodes | Entry age > 24h | Group by tag overlap > 0.3, summarize | +| episodes -> knowledge | access_count >= 3 across 3+ sessions | Promote, confidence +0.2 | +| knowledge -> procedures | 5+ related entries with shared applies_to | Extract workflow | +| any -> .archive | confidence < 0.1 | Move to .archive/ | +| .archive -> delete | age > 90 days AND confidence < 0.05 | Permanent removal | + +# Source Provenance + +| Value | Meaning | +|-------|---------| +| written | Authored by a human or agent (default when field absent) | +| inferred | Generated by memory.infer from structural analysis — may be outdated after major refactors | +| extracted | Derived directly from index data (reserved for future use) | + +Lint flags `inferred` entries older than 30 days as candidates for re-inference. diff --git a/.scout/memory/synonyms.json b/.scout/memory/synonyms.json new file mode 100644 index 0000000..4ae37c9 --- /dev/null +++ b/.scout/memory/synonyms.json @@ -0,0 +1,6010 @@ +{ + "forward": { + "timer-delay": [ + [ + "stlab_v2_system_timer_submit", + 1.0 + ], + [ + "system-timer", + 1.0 + ], + [ + "system_timer", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "stlab-v2-system-timer-submit", + 1.0 + ], + [ + "portable_timers", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "timer_delay", + 1.0 + ], + [ + "timer_status", + 1.0 + ] + ], + "stlab_v2_default_executor_submit": [ + [ + "thread-pool", + 1.0 + ], + [ + "default_executor", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "priority_task_system", + 1.0 + ], + [ + "thread_pool", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "priority-task-system", + 1.0 + ], + [ + "stlab-v2-default-executor-submit", + 1.0 + ] + ], + "synchronization_invariants": [ + [ + "locking_rules", + 1.0 + ], + [ + "synchronization-invariants", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ], + [ + "mutex-discipline", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ], + [ + "concurrency-contracts", + 1.0 + ], + [ + "locking-rules", + 1.0 + ], + [ + "lock-scoping", + 1.0 + ] + ], + "stlab_pre_exit": [ + [ + "process-shutdown", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "core_shutdown", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "pre_exit", + 1.0 + ], + [ + "process_shutdown", + 1.0 + ], + [ + "core-shutdown", + 1.0 + ] + ], + "type-erasure": [ + [ + "stlab_v2_task_concept", + 1.0 + ], + [ + "move_only_task", + 1.0 + ], + [ + "move-only-task", + 1.0 + ], + [ + "stlab-v2-task-concept", + 1.0 + ], + [ + "task", + 1.0 + ], + [ + "task-t", + 1.0 + ], + [ + "task_t", + 1.0 + ], + [ + "type_erasure", + 1.0 + ] + ], + "build_system": [ + [ + "build-system", + 1.0 + ], + [ + "ctest_matrix", + 1.0 + ], + [ + "cmake-presets", + 1.0 + ], + [ + "test-infrastructure", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ], + [ + "cmake_presets", + 1.0 + ], + [ + "cpp-library", + 1.0 + ], + [ + "cpp_library", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ] + ], + "portable_main_executor": [ + [ + "main_queue", + 1.0 + ], + [ + "main-task-queue", + 1.0 + ], + [ + "main-executor", + 1.0 + ], + [ + "main-queue", + 1.0 + ], + [ + "portable-main-executor", + 1.0 + ], + [ + "main_task_queue", + 1.0 + ], + [ + "main_executor", + 1.0 + ] + ], + "main_task_queue": [ + [ + "main-task-queue", + 1.0 + ], + [ + "main_queue", + 1.0 + ], + [ + "main_executor", + 1.0 + ], + [ + "portable_main_executor", + 1.0 + ], + [ + "portable-main-executor", + 1.0 + ], + [ + "main-queue", + 1.0 + ], + [ + "main-executor", + 1.0 + ] + ], + "main_queue": [ + [ + "main_executor", + 1.0 + ], + [ + "main-queue", + 1.0 + ], + [ + "main_task_queue", + 1.0 + ], + [ + "portable_main_executor", + 1.0 + ], + [ + "main-executor", + 1.0 + ], + [ + "portable-main-executor", + 1.0 + ], + [ + "main-task-queue", + 1.0 + ] + ], + "executor_abi": [ + [ + "priority_task_system", + 1.0 + ], + [ + "thread_pool", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "thread-pool", + 1.0 + ], + [ + "priority-task-system", + 1.0 + ], + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "default_executor", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "stlab-v2-default-executor-submit", + 1.0 + ] + ], + "cmake_presets": [ + [ + "cmake-presets", + 1.0 + ], + [ + "build_system", + 1.0 + ], + [ + "cpp-library", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ], + [ + "ctest_matrix", + 1.0 + ], + [ + "cpp_library", + 1.0 + ], + [ + "build-system", + 1.0 + ], + [ + "test-infrastructure", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ] + ], + "abi_stability": [ + [ + "task-abi-guard", + 1.0 + ], + [ + "shared_library_abi", + 1.0 + ], + [ + "execution-def", + 1.0 + ], + [ + "shared-library-abi", + 1.0 + ], + [ + "version-namespaces", + 1.0 + ], + [ + "execution_def", + 1.0 + ], + [ + "version_namespaces", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "abi-stability", + 1.0 + ] + ], + "test-infrastructure": [ + [ + "cpp-library", + 1.0 + ], + [ + "cmake-presets", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ], + [ + "build-system", + 1.0 + ], + [ + "build_system", + 1.0 + ], + [ + "cmake_presets", + 1.0 + ], + [ + "ctest_matrix", + 1.0 + ], + [ + "cpp_library", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ] + ], + "concurrency_contracts": [ + [ + "synchronization-invariants", + 1.0 + ], + [ + "locking-rules", + 1.0 + ], + [ + "lock-scoping", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ], + [ + "concurrency-contracts", + 1.0 + ], + [ + "locking_rules", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ], + [ + "mutex-discipline", + 1.0 + ], + [ + "synchronization_invariants", + 1.0 + ] + ], + "concurrency_runtime": [ + [ + "concurrency-runtime", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "stlab_execution", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ], + [ + "stlab_concurrency", + 1.0 + ], + [ + "architecture-overview", + 1.0 + ], + [ + "execution-runtime", + 1.0 + ], + [ + "stlab-execution", + 1.0 + ] + ], + "lock_scoping": [ + [ + "locking-rules", + 1.0 + ], + [ + "locking_rules", + 1.0 + ], + [ + "synchronization_invariants", + 1.0 + ], + [ + "synchronization-invariants", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "concurrency-contracts", + 1.0 + ], + [ + "lock-scoping", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ], + [ + "mutex-discipline", + 1.0 + ] + ], + "task": [ + [ + "move-only-task", + 1.0 + ], + [ + "task-t", + 1.0 + ], + [ + "type-erasure", + 1.0 + ], + [ + "stlab-v2-task-concept", + 1.0 + ], + [ + "move_only_task", + 1.0 + ], + [ + "stlab_v2_task_concept", + 1.0 + ], + [ + "task_t", + 1.0 + ], + [ + "type_erasure", + 1.0 + ] + ], + "thread-pool": [ + [ + "default_executor", + 1.0 + ], + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "priority-task-system", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "thread_pool", + 1.0 + ], + [ + "stlab-v2-default-executor-submit", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "priority_task_system", + 1.0 + ] + ], + "build-system": [ + [ + "test-infrastructure", + 1.0 + ], + [ + "cmake_presets", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ], + [ + "cpp-library", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ], + [ + "cpp_library", + 1.0 + ], + [ + "cmake-presets", + 1.0 + ], + [ + "ctest_matrix", + 1.0 + ], + [ + "build_system", + 1.0 + ] + ], + "locking-rules": [ + [ + "lock-scoping", + 1.0 + ], + [ + "synchronization-invariants", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "locking_rules", + 1.0 + ], + [ + "synchronization_invariants", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ], + [ + "concurrency-contracts", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ], + [ + "mutex-discipline", + 1.0 + ] + ], + "stlab-execution": [ + [ + "stlab_execution", + 1.0 + ], + [ + "concurrency-runtime", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "architecture-overview", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ], + [ + "execution-runtime", + 1.0 + ], + [ + "stlab_concurrency", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ] + ], + "wasm_pre_exit": [ + [ + "threadless_wasm", + 1.0 + ], + [ + "cooperative-executor", + 1.0 + ], + [ + "threadless-wasm", + 1.0 + ], + [ + "cooperative_executor", + 1.0 + ], + [ + "emscripten", + 1.0 + ], + [ + "webassembly-execution", + 1.0 + ], + [ + "wasm-pre-exit", + 1.0 + ], + [ + "webassembly_execution", + 1.0 + ] + ], + "system_timer": [ + [ + "system-timer", + 1.0 + ], + [ + "timer_delay", + 1.0 + ], + [ + "portable_timers", + 1.0 + ], + [ + "timer-delay", + 1.0 + ], + [ + "stlab-v2-system-timer-submit", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "timer_status", + 1.0 + ], + [ + "stlab_v2_system_timer_submit", + 1.0 + ] + ], + "timer-status": [ + [ + "portable_timers", + 1.0 + ], + [ + "timer_delay", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "system-timer", + 1.0 + ], + [ + "stlab_v2_system_timer_submit", + 1.0 + ], + [ + "stlab-v2-system-timer-submit", + 1.0 + ], + [ + "timer_status", + 1.0 + ], + [ + "system_timer", + 1.0 + ], + [ + "timer-delay", + 1.0 + ] + ], + "stlab-pre-exit": [ + [ + "pre_exit", + 1.0 + ], + [ + "process_shutdown", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ], + [ + "stlab_pre_exit", + 1.0 + ], + [ + "process-shutdown", + 1.0 + ], + [ + "core-shutdown", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "core_shutdown", + 1.0 + ] + ], + "version-namespaces": [ + [ + "version_namespaces", + 1.0 + ], + [ + "abi_stability", + 1.0 + ], + [ + "shared-library-abi", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "abi-stability", + 1.0 + ], + [ + "execution-def", + 1.0 + ], + [ + "task-abi-guard", + 1.0 + ], + [ + "shared_library_abi", + 1.0 + ], + [ + "execution_def", + 1.0 + ] + ], + "execution-def": [ + [ + "shared_library_abi", + 1.0 + ], + [ + "execution_def", + 1.0 + ], + [ + "version_namespaces", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "task-abi-guard", + 1.0 + ], + [ + "abi-stability", + 1.0 + ], + [ + "version-namespaces", + 1.0 + ], + [ + "abi_stability", + 1.0 + ], + [ + "shared-library-abi", + 1.0 + ] + ], + "test_infrastructure": [ + [ + "cpp_library", + 1.0 + ], + [ + "build-system", + 1.0 + ], + [ + "cmake_presets", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ], + [ + "cpp-library", + 1.0 + ], + [ + "ctest_matrix", + 1.0 + ], + [ + "build_system", + 1.0 + ], + [ + "test-infrastructure", + 1.0 + ], + [ + "cmake-presets", + 1.0 + ] + ], + "stlab-v2-system-timer-submit": [ + [ + "timer-delay", + 1.0 + ], + [ + "portable_timers", + 1.0 + ], + [ + "timer_delay", + 1.0 + ], + [ + "system-timer", + 1.0 + ], + [ + "timer_status", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "stlab_v2_system_timer_submit", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "system_timer", + 1.0 + ] + ], + "main-task-queue": [ + [ + "portable_main_executor", + 1.0 + ], + [ + "main_task_queue", + 1.0 + ], + [ + "main_queue", + 1.0 + ], + [ + "main-executor", + 1.0 + ], + [ + "portable-main-executor", + 1.0 + ], + [ + "main_executor", + 1.0 + ], + [ + "main-queue", + 1.0 + ] + ], + "process-shutdown": [ + [ + "core-shutdown", + 1.0 + ], + [ + "pre_exit", + 1.0 + ], + [ + "core_shutdown", + 1.0 + ], + [ + "stlab_pre_exit", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "process_shutdown", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ] + ], + "concurrency-runtime": [ + [ + "stlab_execution", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ], + [ + "architecture-overview", + 1.0 + ], + [ + "stlab-execution", + 1.0 + ], + [ + "stlab_concurrency", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "execution-runtime", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ] + ], + "webassembly-execution": [ + [ + "threadless_wasm", + 1.0 + ], + [ + "threadless-wasm", + 1.0 + ], + [ + "cooperative_executor", + 1.0 + ], + [ + "wasm_pre_exit", + 1.0 + ], + [ + "emscripten", + 1.0 + ], + [ + "cooperative-executor", + 1.0 + ], + [ + "wasm-pre-exit", + 1.0 + ], + [ + "webassembly_execution", + 1.0 + ] + ], + "shared_library_abi": [ + [ + "execution_def", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "execution-def", + 1.0 + ], + [ + "abi_stability", + 1.0 + ], + [ + "version_namespaces", + 1.0 + ], + [ + "abi-stability", + 1.0 + ], + [ + "task-abi-guard", + 1.0 + ], + [ + "version-namespaces", + 1.0 + ], + [ + "shared-library-abi", + 1.0 + ] + ], + "priority-task-system": [ + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "priority_task_system", + 1.0 + ], + [ + "stlab-v2-default-executor-submit", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "default_executor", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "thread_pool", + 1.0 + ], + [ + "thread-pool", + 1.0 + ] + ], + "stlab_execution": [ + [ + "architecture-overview", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "concurrency-runtime", + 1.0 + ], + [ + "stlab_concurrency", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ], + [ + "stlab-execution", + 1.0 + ], + [ + "execution-runtime", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ] + ], + "portable-main-executor": [ + [ + "main_executor", + 1.0 + ], + [ + "main-queue", + 1.0 + ], + [ + "main_task_queue", + 1.0 + ], + [ + "main-executor", + 1.0 + ], + [ + "main-task-queue", + 1.0 + ], + [ + "main_queue", + 1.0 + ], + [ + "portable_main_executor", + 1.0 + ] + ], + "task_t": [ + [ + "type-erasure", + 1.0 + ], + [ + "stlab-v2-task-concept", + 1.0 + ], + [ + "task-t", + 1.0 + ], + [ + "move-only-task", + 1.0 + ], + [ + "move_only_task", + 1.0 + ], + [ + "stlab_v2_task_concept", + 1.0 + ], + [ + "task", + 1.0 + ], + [ + "type_erasure", + 1.0 + ] + ], + "cmake-presets": [ + [ + "build_system", + 1.0 + ], + [ + "cmake_presets", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ], + [ + "test-infrastructure", + 1.0 + ], + [ + "cpp-library", + 1.0 + ], + [ + "ctest_matrix", + 1.0 + ], + [ + "cpp_library", + 1.0 + ], + [ + "build-system", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ] + ], + "type_erasure": [ + [ + "move_only_task", + 1.0 + ], + [ + "task-t", + 1.0 + ], + [ + "type-erasure", + 1.0 + ], + [ + "task_t", + 1.0 + ], + [ + "stlab-v2-task-concept", + 1.0 + ], + [ + "move-only-task", + 1.0 + ], + [ + "task", + 1.0 + ], + [ + "stlab_v2_task_concept", + 1.0 + ] + ], + "architecture_overview": [ + [ + "architecture-overview", + 1.0 + ], + [ + "concurrency-runtime", + 1.0 + ], + [ + "stlab_concurrency", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ], + [ + "stlab-execution", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "execution-runtime", + 1.0 + ], + [ + "stlab_execution", + 1.0 + ] + ], + "mutex_discipline": [ + [ + "lock-scoping", + 1.0 + ], + [ + "mutex-discipline", + 1.0 + ], + [ + "locking-rules", + 1.0 + ], + [ + "synchronization-invariants", + 1.0 + ], + [ + "synchronization_invariants", + 1.0 + ], + [ + "concurrency-contracts", + 1.0 + ], + [ + "locking_rules", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ] + ], + "cpp-library": [ + [ + "ctest_matrix", + 1.0 + ], + [ + "cmake_presets", + 1.0 + ], + [ + "test-infrastructure", + 1.0 + ], + [ + "build_system", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ], + [ + "cmake-presets", + 1.0 + ], + [ + "cpp_library", + 1.0 + ], + [ + "build-system", + 1.0 + ] + ], + "portable-timers": [ + [ + "system_timer", + 1.0 + ], + [ + "timer-delay", + 1.0 + ], + [ + "timer_delay", + 1.0 + ], + [ + "portable_timers", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "stlab_v2_system_timer_submit", + 1.0 + ], + [ + "stlab-v2-system-timer-submit", + 1.0 + ], + [ + "system-timer", + 1.0 + ], + [ + "timer_status", + 1.0 + ] + ], + "at-pre-exit": [ + [ + "process_shutdown", + 1.0 + ], + [ + "core_shutdown", + 1.0 + ], + [ + "stlab_pre_exit", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ], + [ + "pre_exit", + 1.0 + ], + [ + "core-shutdown", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "process-shutdown", + 1.0 + ] + ], + "cooperative_executor": [ + [ + "webassembly_execution", + 1.0 + ], + [ + "threadless-wasm", + 1.0 + ], + [ + "wasm_pre_exit", + 1.0 + ], + [ + "threadless_wasm", + 1.0 + ], + [ + "emscripten", + 1.0 + ], + [ + "cooperative-executor", + 1.0 + ], + [ + "wasm-pre-exit", + 1.0 + ], + [ + "webassembly-execution", + 1.0 + ] + ], + "task-t": [ + [ + "move-only-task", + 1.0 + ], + [ + "type_erasure", + 1.0 + ], + [ + "stlab_v2_task_concept", + 1.0 + ], + [ + "stlab-v2-task-concept", + 1.0 + ], + [ + "move_only_task", + 1.0 + ], + [ + "type-erasure", + 1.0 + ], + [ + "task_t", + 1.0 + ], + [ + "task", + 1.0 + ] + ], + "at_pre_exit": [ + [ + "pre_exit", + 1.0 + ], + [ + "core_shutdown", + 1.0 + ], + [ + "core-shutdown", + 1.0 + ], + [ + "process_shutdown", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "process-shutdown", + 1.0 + ], + [ + "stlab_pre_exit", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ] + ], + "stlab-concurrency": [ + [ + "stlab-execution", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "stlab_execution", + 1.0 + ], + [ + "stlab_concurrency", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ], + [ + "execution-runtime", + 1.0 + ], + [ + "concurrency-runtime", + 1.0 + ], + [ + "architecture-overview", + 1.0 + ] + ], + "timer_delay": [ + [ + "portable_timers", + 1.0 + ], + [ + "stlab_v2_system_timer_submit", + 1.0 + ], + [ + "system-timer", + 1.0 + ], + [ + "timer-delay", + 1.0 + ], + [ + "system_timer", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "timer_status", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "stlab-v2-system-timer-submit", + 1.0 + ] + ], + "ctest_matrix": [ + [ + "build-system", + 1.0 + ], + [ + "cmake-presets", + 1.0 + ], + [ + "cmake_presets", + 1.0 + ], + [ + "cpp-library", + 1.0 + ], + [ + "cpp_library", + 1.0 + ], + [ + "test-infrastructure", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ], + [ + "build_system", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ] + ], + "portable_timers": [ + [ + "timer_delay", + 1.0 + ], + [ + "stlab_v2_system_timer_submit", + 1.0 + ], + [ + "timer_status", + 1.0 + ], + [ + "stlab-v2-system-timer-submit", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "system-timer", + 1.0 + ], + [ + "system_timer", + 1.0 + ], + [ + "timer-delay", + 1.0 + ] + ], + "lock-scoping": [ + [ + "locking_rules", + 1.0 + ], + [ + "synchronization_invariants", + 1.0 + ], + [ + "concurrency-contracts", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "mutex-discipline", + 1.0 + ], + [ + "synchronization-invariants", + 1.0 + ], + [ + "locking-rules", + 1.0 + ] + ], + "stlab_v2_task_concept": [ + [ + "type_erasure", + 1.0 + ], + [ + "move-only-task", + 1.0 + ], + [ + "move_only_task", + 1.0 + ], + [ + "task", + 1.0 + ], + [ + "task-t", + 1.0 + ], + [ + "type-erasure", + 1.0 + ], + [ + "stlab-v2-task-concept", + 1.0 + ], + [ + "task_t", + 1.0 + ] + ], + "main-queue": [ + [ + "main-executor", + 1.0 + ], + [ + "portable_main_executor", + 1.0 + ], + [ + "main_task_queue", + 1.0 + ], + [ + "main_executor", + 1.0 + ], + [ + "portable-main-executor", + 1.0 + ], + [ + "main_queue", + 1.0 + ], + [ + "main-task-queue", + 1.0 + ] + ], + "abi-stability": [ + [ + "execution_def", + 1.0 + ], + [ + "shared-library-abi", + 1.0 + ], + [ + "version-namespaces", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "execution-def", + 1.0 + ], + [ + "version_namespaces", + 1.0 + ], + [ + "task-abi-guard", + 1.0 + ], + [ + "shared_library_abi", + 1.0 + ], + [ + "abi_stability", + 1.0 + ] + ], + "threadless-wasm": [ + [ + "webassembly_execution", + 1.0 + ], + [ + "wasm-pre-exit", + 1.0 + ], + [ + "threadless_wasm", + 1.0 + ], + [ + "emscripten", + 1.0 + ], + [ + "webassembly-execution", + 1.0 + ], + [ + "cooperative_executor", + 1.0 + ], + [ + "cooperative-executor", + 1.0 + ], + [ + "wasm_pre_exit", + 1.0 + ] + ], + "ctest-matrix": [ + [ + "cmake_presets", + 1.0 + ], + [ + "cpp_library", + 1.0 + ], + [ + "ctest_matrix", + 1.0 + ], + [ + "cmake-presets", + 1.0 + ], + [ + "build-system", + 1.0 + ], + [ + "test-infrastructure", + 1.0 + ], + [ + "build_system", + 1.0 + ], + [ + "cpp-library", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ] + ], + "stlab-v2-task-concept": [ + [ + "task_t", + 1.0 + ], + [ + "move_only_task", + 1.0 + ], + [ + "task-t", + 1.0 + ], + [ + "task", + 1.0 + ], + [ + "move-only-task", + 1.0 + ], + [ + "stlab_v2_task_concept", + 1.0 + ], + [ + "type_erasure", + 1.0 + ], + [ + "type-erasure", + 1.0 + ] + ], + "emscripten": [ + [ + "wasm-pre-exit", + 1.0 + ], + [ + "wasm_pre_exit", + 1.0 + ], + [ + "webassembly-execution", + 1.0 + ], + [ + "threadless-wasm", + 1.0 + ], + [ + "cooperative_executor", + 1.0 + ], + [ + "cooperative-executor", + 1.0 + ], + [ + "threadless_wasm", + 1.0 + ], + [ + "webassembly_execution", + 1.0 + ] + ], + "system-timer": [ + [ + "stlab_v2_system_timer_submit", + 1.0 + ], + [ + "portable_timers", + 1.0 + ], + [ + "timer_status", + 1.0 + ], + [ + "stlab-v2-system-timer-submit", + 1.0 + ], + [ + "timer_delay", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "timer-delay", + 1.0 + ], + [ + "system_timer", + 1.0 + ] + ], + "version_namespaces": [ + [ + "version-namespaces", + 1.0 + ], + [ + "abi_stability", + 1.0 + ], + [ + "execution-def", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "execution_def", + 1.0 + ], + [ + "shared-library-abi", + 1.0 + ], + [ + "abi-stability", + 1.0 + ], + [ + "shared_library_abi", + 1.0 + ], + [ + "task-abi-guard", + 1.0 + ] + ], + "execution_def": [ + [ + "shared_library_abi", + 1.0 + ], + [ + "abi-stability", + 1.0 + ], + [ + "task-abi-guard", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "abi_stability", + 1.0 + ], + [ + "execution-def", + 1.0 + ], + [ + "shared-library-abi", + 1.0 + ], + [ + "version_namespaces", + 1.0 + ], + [ + "version-namespaces", + 1.0 + ] + ], + "main_executor": [ + [ + "main-executor", + 1.0 + ], + [ + "main-queue", + 1.0 + ], + [ + "portable-main-executor", + 1.0 + ], + [ + "portable_main_executor", + 1.0 + ], + [ + "main_task_queue", + 1.0 + ], + [ + "main-task-queue", + 1.0 + ], + [ + "main_queue", + 1.0 + ] + ], + "default_executor": [ + [ + "stlab-v2-default-executor-submit", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "thread-pool", + 1.0 + ], + [ + "priority-task-system", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "priority_task_system", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "thread_pool", + 1.0 + ] + ], + "wasm-pre-exit": [ + [ + "emscripten", + 1.0 + ], + [ + "webassembly_execution", + 1.0 + ], + [ + "threadless_wasm", + 1.0 + ], + [ + "cooperative_executor", + 1.0 + ], + [ + "threadless-wasm", + 1.0 + ], + [ + "cooperative-executor", + 1.0 + ], + [ + "wasm_pre_exit", + 1.0 + ], + [ + "webassembly-execution", + 1.0 + ] + ], + "priority_task_system": [ + [ + "priority-task-system", + 1.0 + ], + [ + "thread-pool", + 1.0 + ], + [ + "thread_pool", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "default_executor", + 1.0 + ], + [ + "stlab-v2-default-executor-submit", + 1.0 + ] + ], + "cpp_library": [ + [ + "cmake_presets", + 1.0 + ], + [ + "test_infrastructure", + 1.0 + ], + [ + "test-infrastructure", + 1.0 + ], + [ + "cpp-library", + 1.0 + ], + [ + "cmake-presets", + 1.0 + ], + [ + "build-system", + 1.0 + ], + [ + "ctest_matrix", + 1.0 + ], + [ + "ctest-matrix", + 1.0 + ], + [ + "build_system", + 1.0 + ] + ], + "default-executor": [ + [ + "stlab-v2-default-executor-submit", + 1.0 + ], + [ + "priority-task-system", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "thread-pool", + 1.0 + ], + [ + "thread_pool", + 1.0 + ], + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "priority_task_system", + 1.0 + ], + [ + "default_executor", + 1.0 + ] + ], + "move-only-task": [ + [ + "type_erasure", + 1.0 + ], + [ + "move_only_task", + 1.0 + ], + [ + "type-erasure", + 1.0 + ], + [ + "stlab-v2-task-concept", + 1.0 + ], + [ + "task", + 1.0 + ], + [ + "task_t", + 1.0 + ], + [ + "task-t", + 1.0 + ], + [ + "stlab_v2_task_concept", + 1.0 + ] + ], + "mutex-discipline": [ + [ + "synchronization_invariants", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "concurrency-contracts", + 1.0 + ], + [ + "locking_rules", + 1.0 + ], + [ + "locking-rules", + 1.0 + ], + [ + "synchronization-invariants", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ], + [ + "lock-scoping", + 1.0 + ] + ], + "executor-abi": [ + [ + "priority_task_system", + 1.0 + ], + [ + "thread_pool", + 1.0 + ], + [ + "thread-pool", + 1.0 + ], + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "priority-task-system", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "default_executor", + 1.0 + ], + [ + "stlab-v2-default-executor-submit", + 1.0 + ] + ], + "threadless_wasm": [ + [ + "emscripten", + 1.0 + ], + [ + "wasm-pre-exit", + 1.0 + ], + [ + "webassembly_execution", + 1.0 + ], + [ + "webassembly-execution", + 1.0 + ], + [ + "wasm_pre_exit", + 1.0 + ], + [ + "cooperative_executor", + 1.0 + ], + [ + "cooperative-executor", + 1.0 + ], + [ + "threadless-wasm", + 1.0 + ] + ], + "stlab-v2-default-executor-submit": [ + [ + "thread_pool", + 1.0 + ], + [ + "thread-pool", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "priority_task_system", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "default_executor", + 1.0 + ], + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "priority-task-system", + 1.0 + ] + ], + "stlab_v2_system_timer_submit": [ + [ + "timer_delay", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "timer_status", + 1.0 + ], + [ + "timer-delay", + 1.0 + ], + [ + "system-timer", + 1.0 + ], + [ + "system_timer", + 1.0 + ], + [ + "portable_timers", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "stlab-v2-system-timer-submit", + 1.0 + ] + ], + "stlab_concurrency": [ + [ + "execution-runtime", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ], + [ + "stlab-execution", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ], + [ + "concurrency-runtime", + 1.0 + ], + [ + "architecture-overview", + 1.0 + ], + [ + "stlab_execution", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ] + ], + "thread_pool": [ + [ + "priority-task-system", + 1.0 + ], + [ + "default-executor", + 1.0 + ], + [ + "priority_task_system", + 1.0 + ], + [ + "stlab_v2_default_executor_submit", + 1.0 + ], + [ + "thread-pool", + 1.0 + ], + [ + "executor_abi", + 1.0 + ], + [ + "executor-abi", + 1.0 + ], + [ + "default_executor", + 1.0 + ], + [ + "stlab-v2-default-executor-submit", + 1.0 + ] + ], + "timer_status": [ + [ + "stlab-v2-system-timer-submit", + 1.0 + ], + [ + "portable_timers", + 1.0 + ], + [ + "system_timer", + 1.0 + ], + [ + "timer-delay", + 1.0 + ], + [ + "stlab_v2_system_timer_submit", + 1.0 + ], + [ + "timer-status", + 1.0 + ], + [ + "portable-timers", + 1.0 + ], + [ + "system-timer", + 1.0 + ], + [ + "timer_delay", + 1.0 + ] + ], + "process_shutdown": [ + [ + "stlab_pre_exit", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "process-shutdown", + 1.0 + ], + [ + "pre_exit", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ], + [ + "core_shutdown", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ], + [ + "core-shutdown", + 1.0 + ] + ], + "pre-exit": [ + [ + "stlab_pre_exit", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ], + [ + "core-shutdown", + 1.0 + ], + [ + "process-shutdown", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ], + [ + "pre_exit", + 1.0 + ], + [ + "process_shutdown", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "core_shutdown", + 1.0 + ] + ], + "pre_exit": [ + [ + "core_shutdown", + 1.0 + ], + [ + "core-shutdown", + 1.0 + ], + [ + "process_shutdown", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ], + [ + "process-shutdown", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "stlab_pre_exit", + 1.0 + ] + ], + "core-shutdown": [ + [ + "stlab_pre_exit", + 1.0 + ], + [ + "process_shutdown", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "core_shutdown", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "process-shutdown", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ], + [ + "pre_exit", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ] + ], + "main-executor": [ + [ + "main-queue", + 1.0 + ], + [ + "main_task_queue", + 1.0 + ], + [ + "portable_main_executor", + 1.0 + ], + [ + "main_executor", + 1.0 + ], + [ + "portable-main-executor", + 1.0 + ], + [ + "main-task-queue", + 1.0 + ], + [ + "main_queue", + 1.0 + ] + ], + "cooperative-executor": [ + [ + "cooperative_executor", + 1.0 + ], + [ + "threadless_wasm", + 1.0 + ], + [ + "threadless-wasm", + 1.0 + ], + [ + "emscripten", + 1.0 + ], + [ + "webassembly_execution", + 1.0 + ], + [ + "wasm_pre_exit", + 1.0 + ], + [ + "webassembly-execution", + 1.0 + ], + [ + "wasm-pre-exit", + 1.0 + ] + ], + "synchronization-invariants": [ + [ + "mutex-discipline", + 1.0 + ], + [ + "locking_rules", + 1.0 + ], + [ + "synchronization_invariants", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "locking-rules", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ], + [ + "lock-scoping", + 1.0 + ], + [ + "concurrency-contracts", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ] + ], + "execution-runtime": [ + [ + "stlab_concurrency", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "architecture-overview", + 1.0 + ], + [ + "stlab-execution", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ], + [ + "stlab_execution", + 1.0 + ], + [ + "concurrency-runtime", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ] + ], + "move_only_task": [ + [ + "move-only-task", + 1.0 + ], + [ + "task", + 1.0 + ], + [ + "task-t", + 1.0 + ], + [ + "task_t", + 1.0 + ], + [ + "stlab-v2-task-concept", + 1.0 + ], + [ + "type_erasure", + 1.0 + ], + [ + "type-erasure", + 1.0 + ], + [ + "stlab_v2_task_concept", + 1.0 + ] + ], + "execution_runtime": [ + [ + "architecture-overview", + 1.0 + ], + [ + "execution-runtime", + 1.0 + ], + [ + "stlab_concurrency", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ], + [ + "concurrency-runtime", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ], + [ + "stlab_execution", + 1.0 + ], + [ + "stlab-execution", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ] + ], + "locking_rules": [ + [ + "concurrency-contracts", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ], + [ + "synchronization_invariants", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "synchronization-invariants", + 1.0 + ], + [ + "locking-rules", + 1.0 + ], + [ + "lock-scoping", + 1.0 + ], + [ + "mutex-discipline", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ] + ], + "core_shutdown": [ + [ + "process_shutdown", + 1.0 + ], + [ + "pre-exit", + 1.0 + ], + [ + "stlab_pre_exit", + 1.0 + ], + [ + "stlab-pre-exit", + 1.0 + ], + [ + "at_pre_exit", + 1.0 + ], + [ + "process-shutdown", + 1.0 + ], + [ + "core-shutdown", + 1.0 + ], + [ + "at-pre-exit", + 1.0 + ], + [ + "pre_exit", + 1.0 + ] + ], + "task_abi_guard": [ + [ + "shared-library-abi", + 1.0 + ], + [ + "version_namespaces", + 1.0 + ], + [ + "shared_library_abi", + 1.0 + ], + [ + "abi-stability", + 1.0 + ], + [ + "task-abi-guard", + 1.0 + ], + [ + "execution-def", + 1.0 + ], + [ + "version-namespaces", + 1.0 + ], + [ + "execution_def", + 1.0 + ], + [ + "abi_stability", + 1.0 + ] + ], + "concurrency-contracts": [ + [ + "locking-rules", + 1.0 + ], + [ + "locking_rules", + 1.0 + ], + [ + "synchronization_invariants", + 1.0 + ], + [ + "lock_scoping", + 1.0 + ], + [ + "mutex_discipline", + 1.0 + ], + [ + "concurrency_contracts", + 1.0 + ], + [ + "mutex-discipline", + 1.0 + ], + [ + "lock-scoping", + 1.0 + ], + [ + "synchronization-invariants", + 1.0 + ] + ], + "webassembly_execution": [ + [ + "threadless-wasm", + 1.0 + ], + [ + "webassembly-execution", + 1.0 + ], + [ + "wasm-pre-exit", + 1.0 + ], + [ + "emscripten", + 1.0 + ], + [ + "wasm_pre_exit", + 1.0 + ], + [ + "cooperative_executor", + 1.0 + ], + [ + "cooperative-executor", + 1.0 + ], + [ + "threadless_wasm", + 1.0 + ] + ], + "shared-library-abi": [ + [ + "execution-def", + 1.0 + ], + [ + "abi_stability", + 1.0 + ], + [ + "execution_def", + 1.0 + ], + [ + "abi-stability", + 1.0 + ], + [ + "version_namespaces", + 1.0 + ], + [ + "shared_library_abi", + 1.0 + ], + [ + "version-namespaces", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "task-abi-guard", + 1.0 + ] + ], + "architecture-overview": [ + [ + "concurrency-runtime", + 1.0 + ], + [ + "execution_runtime", + 1.0 + ], + [ + "stlab_concurrency", + 1.0 + ], + [ + "stlab_execution", + 1.0 + ], + [ + "execution-runtime", + 1.0 + ], + [ + "concurrency_runtime", + 1.0 + ], + [ + "stlab-execution", + 1.0 + ], + [ + "stlab-concurrency", + 1.0 + ], + [ + "architecture_overview", + 1.0 + ] + ], + "task-abi-guard": [ + [ + "shared_library_abi", + 1.0 + ], + [ + "execution_def", + 1.0 + ], + [ + "shared-library-abi", + 1.0 + ], + [ + "task_abi_guard", + 1.0 + ], + [ + "abi_stability", + 1.0 + ], + [ + "execution-def", + 1.0 + ], + [ + "abi-stability", + 1.0 + ], + [ + "version-namespaces", + 1.0 + ], + [ + "version_namespaces", + 1.0 + ] + ] + }, + "provenance": { + "concurrency-runtime|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "execution_runtime|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "priority_task_system|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "test_infrastructure|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "architecture-overview|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "version-namespaces|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "core-shutdown|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "pre_exit|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "thread-pool|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "abi-stability|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "webassembly_execution|threadless-wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "task_t|type-erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab_v2_default_executor_submit|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "task_abi_guard|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "portable-timers|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "pre_exit|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "webassembly-execution|emscripten": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "synchronization-invariants|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "task-t|type_erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "type_erasure|task_t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab-v2-task-concept|task_t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "thread-pool|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "move-only-task|stlab-v2-task-concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "default_executor|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "task|task_t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "move_only_task|task_t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "shared_library_abi|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab-v2-system-timer-submit|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "process-shutdown|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "wasm_pre_exit|emscripten": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "version_namespaces|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "lock-scoping|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab_v2_system_timer_submit|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "abi-stability|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "process_shutdown|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "concurrency-contracts|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "execution_runtime|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "stlab-v2-task-concept|type-erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "main-queue|portable-main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "threadless_wasm|emscripten": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "execution_def|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "test_infrastructure|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab-pre-exit|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "abi-stability|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab-concurrency|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "ctest-matrix|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "execution-runtime|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "thread-pool|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "type_erasure|type-erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "process_shutdown|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "wasm_pre_exit|threadless_wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "executor-abi|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "stlab-pre-exit|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab-v2-task-concept|move_only_task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "abi-stability|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "system-timer|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "portable_main_executor|portable-main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "concurrency_contracts|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "abi_stability|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "lock_scoping|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "system_timer|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "cpp-library|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "thread_pool|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main-executor|portable-main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "stlab-execution|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "cpp-library|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "portable-main-executor|main_task_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "build_system|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "main-executor|main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "build_system|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "concurrency_contracts|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab-concurrency|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "shared-library-abi|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "core-shutdown|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_pre_exit|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "shared_library_abi|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "webassembly-execution|webassembly_execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "concurrency-contracts|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "concurrency_contracts|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab_concurrency|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "cmake_presets|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "emscripten|cooperative_executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "executor_abi|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "threadless-wasm|cooperative-executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-v2-task-concept|stlab_v2_task_concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "at_pre_exit|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_concurrency|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "default-executor|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "version_namespaces|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "mutex_discipline|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "version_namespaces|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "move_only_task|task-t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "wasm_pre_exit|cooperative-executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-v2-task-concept|move-only-task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "locking-rules|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "core-shutdown|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "core-shutdown|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "main_task_queue|main_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "task_abi_guard|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "default-executor|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "executor_abi|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "thread-pool|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "mutex_discipline|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "type-erasure|stlab-v2-task-concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab-pre-exit|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "concurrency_contracts|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "version-namespaces|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "build-system|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "cmake_presets|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "type-erasure|move-only-task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "lock-scoping|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "timer-status|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "stlab-v2-system-timer-submit|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "thread-pool|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main_task_queue|main-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "synchronization_invariants|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "timer-status|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "priority-task-system|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "pre_exit|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "execution-def|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab-concurrency|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "cpp-library|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "task_t|stlab-v2-task-concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "locking_rules|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "webassembly_execution|wasm_pre_exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "main_queue|portable-main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "cmake-presets|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "thread_pool|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "timer-status|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "shared-library-abi|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "execution_runtime|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "stlab-v2-default-executor-submit|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "lock_scoping|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "task|stlab_v2_task_concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "ctest-matrix|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "timer_delay|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "architecture_overview|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "abi_stability|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab-v2-default-executor-submit|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "execution_runtime|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "stlab_v2_system_timer_submit|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "concurrency-contracts|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "process-shutdown|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "build_system|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab-v2-task-concept|task-t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "move-only-task|type_erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "architecture_overview|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "stlab-v2-system-timer-submit|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "abi_stability|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "priority_task_system|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "cooperative_executor|wasm_pre_exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab_concurrency|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "at-pre-exit|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "execution_def|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "default_executor|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "stlab-v2-task-concept|task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "execution_def|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "version_namespaces|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "architecture_overview|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "task|move-only-task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "threadless_wasm|webassembly_execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "lock_scoping|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "threadless-wasm|threadless_wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "webassembly_execution|cooperative_executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "task-t|move_only_task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "architecture-overview|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "synchronization-invariants|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "main_executor|portable_main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "lock_scoping|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "abi-stability|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab_v2_task_concept|stlab-v2-task-concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "default_executor|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "architecture-overview|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "stlab_execution|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "type-erasure|move_only_task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "at_pre_exit|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "main_queue|portable_main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "main_task_queue|main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "concurrency_runtime|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "lock-scoping|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "system_timer|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "lock_scoping|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "cmake_presets|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "thread-pool|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "threadless_wasm|cooperative_executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-v2-default-executor-submit|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "concurrency-runtime|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "build_system|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "task|type-erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "main-executor|main-task-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "stlab_v2_default_executor_submit|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "test-infrastructure|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "concurrency_contracts|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "default_executor|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main_executor|main-task-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "at-pre-exit|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_execution|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "concurrency_runtime|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "timer_delay|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "task-abi-guard|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "locking-rules|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "executor_abi|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "cpp-library|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "at-pre-exit|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "cpp-library|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "ctest-matrix|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "move_only_task|stlab-v2-task-concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "threadless-wasm|webassembly-execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "portable_main_executor|main_task_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "timer_status|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "default_executor|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main_executor|main_task_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "core_shutdown|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "pre_exit|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "system_timer|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "main-queue|portable_main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "at_pre_exit|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "executor_abi|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "stlab_v2_default_executor_submit|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "executor-abi|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "move-only-task|move_only_task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "system-timer|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "cmake-presets|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "task-abi-guard|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "main-executor|main-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "task|stlab-v2-task-concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab_v2_system_timer_submit|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "webassembly_execution|webassembly-execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab_v2_system_timer_submit|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "build-system|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "main-queue|main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "move_only_task|type-erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab-v2-system-timer-submit|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "webassembly-execution|cooperative_executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "lock-scoping|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "execution_runtime|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "stlab_pre_exit|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "portable-main-executor|portable_main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "concurrency_runtime|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "mutex-discipline|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "priority-task-system|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "priority_task_system|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "architecture_overview|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "synchronization_invariants|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "mutex-discipline|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "test_infrastructure|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "concurrency-contracts|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "ctest_matrix|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "mutex-discipline|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "system-timer|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "concurrency-contracts|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "build_system|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab-execution|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "abi_stability|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "wasm_pre_exit|threadless-wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "task_t|move-only-task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "default_executor|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "cooperative-executor|webassembly-execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "ctest_matrix|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "type-erasure|task-t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "executor_abi|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "system_timer|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "concurrency-contracts|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "process-shutdown|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "synchronization-invariants|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "wasm-pre-exit|wasm_pre_exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "mutex-discipline|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "core_shutdown|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab-concurrency|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "portable-main-executor|main-task-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "execution-def|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "main_task_queue|portable-main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "stlab_concurrency|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "lock-scoping|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "task-abi-guard|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "process-shutdown|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "version-namespaces|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "thread_pool|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "default-executor|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "ctest_matrix|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "task|move_only_task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "process_shutdown|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "thread_pool|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "stlab_v2_system_timer_submit|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "core_shutdown|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_v2_system_timer_submit|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "mutex-discipline|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "pre-exit|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "threadless-wasm|cooperative_executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "abi-stability|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab_execution|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "main_queue|main-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "portable_main_executor|main-task-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "task_t|move_only_task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "concurrency_runtime|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "execution_def|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "portable_timers|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "cpp-library|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "priority-task-system|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "test_infrastructure|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "system_timer|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "process-shutdown|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "default_executor|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "emscripten|cooperative-executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "default_executor|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "execution_runtime|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "execution_def|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "execution-runtime|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "locking_rules|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab_execution|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "executor-abi|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "pre-exit|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "locking_rules|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "thread_pool|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "system-timer|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "priority_task_system|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main_queue|main_task_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "timer-delay|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "synchronization-invariants|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "emscripten|wasm-pre-exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "synchronization-invariants|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "pre_exit|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "wasm-pre-exit|webassembly_execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "system_timer|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "main-task-queue|main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "timer_delay|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "timer-delay|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "cmake-presets|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "cmake_presets|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "task_abi_guard|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "task-t|stlab_v2_task_concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "timer-delay|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "priority-task-system|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main_executor|main_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "portable-main-executor|main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "concurrency-runtime|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "build-system|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "test-infrastructure|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "synchronization-invariants|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "process_shutdown|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "at-pre-exit|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "locking-rules|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "type_erasure|stlab_v2_task_concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "locking-rules|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "task_abi_guard|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "cmake_presets|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "type-erasure|task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "at_pre_exit|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "portable_timers|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "locking-rules|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "execution-runtime|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "core-shutdown|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "lock-scoping|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "portable-main-executor|main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "execution-def|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "webassembly-execution|threadless-wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-execution|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "execution-runtime|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "version-namespaces|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "move_only_task|stlab_v2_task_concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab_concurrency|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "system-timer|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "execution-runtime|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "cpp-library|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "ctest_matrix|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "pre-exit|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "cooperative_executor|emscripten": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "task-abi-guard|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "thread_pool|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "stlab_pre_exit|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "synchronization-invariants|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab_v2_system_timer_submit|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "concurrency_contracts|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "concurrency-runtime|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "build_system|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "concurrency-runtime|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "stlab-v2-default-executor-submit|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "execution-def|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "cmake-presets|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "ctest_matrix|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "execution_runtime|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "test-infrastructure|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "concurrency_contracts|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "priority-task-system|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "at-pre-exit|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "architecture-overview|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "version_namespaces|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "ctest_matrix|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "concurrency_runtime|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "ctest-matrix|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "default-executor|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "execution_def|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "emscripten|wasm_pre_exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "timer_status|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "default-executor|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "thread_pool|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "timer_delay|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "task_t|task-t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab-concurrency|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "wasm-pre-exit|cooperative-executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "threadless_wasm|threadless-wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "at_pre_exit|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "architecture-overview|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "cooperative_executor|threadless_wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "execution-runtime|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "shared-library-abi|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "at_pre_exit|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "main_queue|main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "execution_def|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "timer-delay|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "task_t|stlab_v2_task_concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "ctest_matrix|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "version_namespaces|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "cmake_presets|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "execution-def|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "priority_task_system|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "system-timer|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "cpp-library|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "timer_delay|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "thread-pool|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "timer_status|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "concurrency_contracts|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "core_shutdown|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "timer-delay|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "timer_status|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "at-pre-exit|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "process_shutdown|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "portable_main_executor|main_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "ctest-matrix|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "executor-abi|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "shared-library-abi|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "threadless_wasm|cooperative-executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "test-infrastructure|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "shared_library_abi|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab-pre-exit|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "main-queue|main_task_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "portable_timers|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "webassembly-execution|wasm-pre-exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-v2-system-timer-submit|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "task-t|task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "lock_scoping|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "executor-abi|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "priority_task_system|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "process-shutdown|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "main-task-queue|main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "portable_main_executor|main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "stlab-v2-task-concept|type_erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "task|task-t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "webassembly-execution|wasm_pre_exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "cooperative_executor|threadless-wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "task_abi_guard|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "main_executor|main-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "execution_runtime|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "cmake-presets|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "core-shutdown|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "architecture_overview|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "synchronization_invariants|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "main-queue|main_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "cmake-presets|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "portable-main-executor|main-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "test_infrastructure|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "locking-rules|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab-concurrency|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "execution_def|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "lock-scoping|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "timer_status|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "stlab-concurrency|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "executor_abi|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "test_infrastructure|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab-execution|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "stlab_v2_default_executor_submit|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "system_timer|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "ctest-matrix|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "shared-library-abi|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "executor_abi|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "mutex-discipline|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "build-system|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "shared_library_abi|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab_pre_exit|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_v2_default_executor_submit|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "portable-timers|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "build-system|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "cpp_library|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "emscripten|webassembly-execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "ctest_matrix|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab-v2-system-timer-submit|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "test-infrastructure|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "webassembly_execution|cooperative-executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "main_queue|main-task-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "portable_main_executor|main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "concurrency-contracts|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab-execution|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "portable-timers|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "portable-timers|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "test_infrastructure|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "main-queue|main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "locking-rules|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "process_shutdown|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "main-executor|main_task_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "concurrency-runtime|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "portable_timers|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "shared_library_abi|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "abi_stability|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "move-only-task|task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab_v2_default_executor_submit|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "ctest_matrix|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "execution-runtime|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "portable-timers|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "cooperative-executor|webassembly_execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "test-infrastructure|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "task_t|type_erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab-v2-system-timer-submit|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "version-namespaces|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab-v2-system-timer-submit|timer_status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "locking-rules|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "mutex_discipline|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab_v2_default_executor_submit|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "concurrency_runtime|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "wasm_pre_exit|webassembly-execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "task_abi_guard|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "cmake-presets|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "version_namespaces|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "move_only_task|move-only-task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "timer_delay|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "cooperative_executor|webassembly_execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "concurrency-runtime|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "cmake-presets|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "system_timer|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "system-timer|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "type_erasure|move-only-task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab_v2_task_concept|task_t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "build_system|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "abi_stability|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "concurrency-runtime|execution_runtime": [ + "knowledge\\architecture-overview.md" + ], + "type-erasure|stlab_v2_task_concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "execution-def|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "timer-status|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "priority_task_system|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main_executor|main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "timer-status|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "move-only-task|task-t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab-execution|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "cooperative_executor|wasm-pre-exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "portable-main-executor|main_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "timer_delay|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "ctest-matrix|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "cpp_library|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "timer-delay|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "stlab_v2_task_concept|type_erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "cmake_presets|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab_execution|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "task|type_erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "portable_main_executor|main-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "cooperative-executor|emscripten": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-pre-exit|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "pre_exit|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "timer_delay|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "mutex_discipline|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "wasm-pre-exit|webassembly-execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "portable-timers|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "cpp_library|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "task-abi-guard|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "concurrency-runtime|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "task-abi-guard|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "task_abi_guard|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "pre-exit|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "process-shutdown|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "ctest-matrix|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "default_executor|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "synchronization_invariants|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab_pre_exit|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "pre-exit|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "version-namespaces|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "lock_scoping|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "portable-timers|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "lock-scoping|synchronization_invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "locking-rules|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab-concurrency|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "pre_exit|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_v2_default_executor_submit|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "task-abi-guard|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "main-task-queue|portable-main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "mutex-discipline|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "abi-stability|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "build-system|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "main-task-queue|main-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "timer_status|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "core-shutdown|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "locking_rules|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "build-system|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "threadless-wasm|wasm_pre_exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab_v2_task_concept|move-only-task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "cpp_library|cmake-presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "timer_delay|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "architecture-overview|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "execution-runtime|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "webassembly_execution|threadless_wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "shared_library_abi|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "threadless_wasm|wasm-pre-exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "pre-exit|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "wasm_pre_exit|cooperative_executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "execution-def|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab_concurrency|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "main-executor|portable_main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "build_system|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "version-namespaces|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab_pre_exit|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "timer-status|stlab_v2_system_timer_submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "version_namespaces|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "concurrency-contracts|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "version-namespaces|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "portable_timers|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "priority_task_system|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "task_t|task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "synchronization-invariants|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "wasm-pre-exit|cooperative_executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "shared_library_abi|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "cooperative-executor|threadless-wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "emscripten|threadless_wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "cooperative-executor|wasm-pre-exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab_v2_task_concept|type-erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab_execution|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "cpp_library|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "locking_rules|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "timer-status|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "emscripten|webassembly_execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-pre-exit|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "portable-timers|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "executor-abi|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "core-shutdown|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "shared-library-abi|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "locking_rules|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "locking_rules|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab_pre_exit|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_execution|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "main-executor|main_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "main_queue|main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "cooperative_executor|webassembly-execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "type_erasure|task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "mutex_discipline|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "threadless_wasm|wasm_pre_exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "build-system|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab_concurrency|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "pre-exit|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_concurrency|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "stlab_v2_task_concept|move_only_task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "task-abi-guard|abi-stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "mutex-discipline|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab-v2-system-timer-submit|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "task_abi_guard|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "shared-library-abi|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab_v2_system_timer_submit|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "threadless-wasm|webassembly_execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "cpp_library|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "cpp_library|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "test_infrastructure|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "main_executor|portable-main-executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "wasm-pre-exit|threadless-wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "architecture-overview|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "timer-status|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "at_pre_exit|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "move_only_task|task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "move-only-task|type-erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab_v2_task_concept|task-t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "execution-runtime|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "portable-timers|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "default-executor|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "at_pre_exit|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "move-only-task|task_t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "system-timer|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "timer-status|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "execution_runtime|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "execution-def|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "shared_library_abi|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "cooperative-executor|threadless_wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "main-task-queue|main_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "core_shutdown|stlab_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "architecture_overview|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "stlab_execution|execution-runtime": [ + "knowledge\\architecture-overview.md" + ], + "pre-exit|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "timer_status|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "abi-stability|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab-pre-exit|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "abi_stability|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab_pre_exit|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "system_timer|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "webassembly-execution|cooperative-executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "architecture_overview|stlab-concurrency": [ + "knowledge\\architecture-overview.md" + ], + "wasm_pre_exit|webassembly_execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "execution-def|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "concurrency_contracts|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "cpp_library|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "build_system|ctest-matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "main-task-queue|portable_main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "priority-task-system|executor_abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "pre-exit|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "timer_status|timer-delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "core-shutdown|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "executor_abi|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "stlab_v2_system_timer_submit|portable_timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "portable_timers|stlab-v2-system-timer-submit": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "executor-abi|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "wasm-pre-exit|threadless_wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "synchronization_invariants|locking_rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "ctest-matrix|build_system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "synchronization_invariants|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "type-erasure|type_erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "process-shutdown|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "mutex_discipline|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "type_erasure|task-t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "main-queue|main-task-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "execution_def|shared-library-abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "pre_exit|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "webassembly-execution|threadless_wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "priority-task-system|stlab-v2-default-executor-submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "priority_task_system|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "type-erasure|task_t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "stlab_pre_exit|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "portable_timers|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "at_pre_exit|at-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "process_shutdown|pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab_concurrency|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "process_shutdown|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "timer-delay|portable-timers": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "default-executor|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "test-infrastructure|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "locking_rules|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "core_shutdown|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "wasm-pre-exit|emscripten": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "architecture_overview|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "version-namespaces|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "type_erasure|stlab-v2-task-concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "thread-pool|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "mutex-discipline|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "task-t|task_t": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "threadless_wasm|webassembly-execution": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-concurrency|architecture-overview": [ + "knowledge\\architecture-overview.md" + ], + "wasm_pre_exit|wasm-pre-exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "thread-pool|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main_task_queue|portable_main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "mutex_discipline|lock_scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "stlab-v2-default-executor-submit|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "main-task-queue|main_task_queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "stlab_v2_task_concept|task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "test_infrastructure|build-system": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "at-pre-exit|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab-pre-exit|core_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "cooperative-executor|wasm_pre_exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "build-system|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "lock_scoping|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "executor-abi|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "concurrency-contracts|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "webassembly_execution|wasm-pre-exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "threadless-wasm|emscripten": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "lock_scoping|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "synchronization-invariants|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "version_namespaces|abi_stability": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "default-executor|executor-abi": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "cooperative-executor|cooperative_executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "task-t|move-only-task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "at-pre-exit|at_pre_exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "executor-abi|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "move-only-task|stlab_v2_task_concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "mutex_discipline|concurrency-contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "synchronization_invariants|locking-rules": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "task-t|type-erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "core_shutdown|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "stlab-execution|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "main_task_queue|main_executor": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "stlab-execution|concurrency-runtime": [ + "knowledge\\architecture-overview.md" + ], + "architecture-overview|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "cmake_presets|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "locking_rules|lock-scoping": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "concurrency_runtime|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "stlab_execution|stlab_concurrency": [ + "knowledge\\architecture-overview.md" + ], + "move_only_task|type_erasure": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "threadless-wasm|wasm-pre-exit": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "cpp_library|cmake_presets": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "task_abi_guard|task-abi-guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "portable_timers|system_timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "shared_library_abi|execution-def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "test-infrastructure|test_infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "abi_stability|shared_library_abi": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "stlab-v2-default-executor-submit|thread-pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "timer-delay|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "lock-scoping|mutex_discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "task-t|stlab-v2-task-concept": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "pre_exit|process-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "priority-task-system|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "concurrency_runtime|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "abi-stability|execution_def": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "type_erasure|move_only_task": [ + "knowledge\\task-type-erasure-and-relocation-abi.md" + ], + "emscripten|threadless-wasm": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab-execution|stlab_execution": [ + "knowledge\\architecture-overview.md" + ], + "mutex_discipline|concurrency_contracts": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "cmake-presets|test-infrastructure": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "timer-delay|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "abi_stability|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "webassembly_execution|emscripten": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "stlab_v2_default_executor_submit|thread_pool": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "architecture_overview|concurrency_runtime": [ + "knowledge\\architecture-overview.md" + ], + "stlab-pre-exit|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "system-timer|timer_delay": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "executor_abi|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "concurrency_runtime|architecture_overview": [ + "knowledge\\architecture-overview.md" + ], + "main_task_queue|main-task-queue": [ + "knowledge\\main-executor-backends-and-dispatch-queue.md" + ], + "task-abi-guard|version_namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "shared-library-abi|version-namespaces": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "priority-task-system|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "shared-library-abi|task_abi_guard": [ + "knowledge\\abi-stability-version-namespaces-and-shared-library-exports.md" + ], + "process-shutdown|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "core_shutdown|pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "architecture-overview|stlab-execution": [ + "knowledge\\architecture-overview.md" + ], + "cooperative_executor|cooperative-executor": [ + "knowledge\\threadless-emscripten-cooperative-execution-and-shutdown.md" + ], + "core_shutdown|process_shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "thread_pool|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "thread_pool|default-executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "test-infrastructure|cpp-library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "cmake_presets|cpp_library": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab-v2-default-executor-submit|stlab_v2_default_executor_submit": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "stlab-v2-default-executor-submit|default_executor": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "cpp-library|ctest_matrix": [ + "procedures\\build-presets-testing-matrix-and-cpp-library-tooling.md" + ], + "stlab-v2-default-executor-submit|priority-task-system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "process_shutdown|core-shutdown": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "synchronization_invariants|synchronization-invariants": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ], + "at-pre-exit|stlab-pre-exit": [ + "knowledge\\process-lifecycle-and-pre-exit-protocol.md" + ], + "timer_status|timer-status": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "portable_timers|system-timer": [ + "knowledge\\system-timer-architecture-and-guarantees.md" + ], + "default-executor|priority_task_system": [ + "knowledge\\executor-architecture-and-native-priority-schedulers.md" + ], + "synchronization_invariants|mutex-discipline": [ + "knowledge\\concurrency-contracts-and-locking-discipline.md" + ] + }, + "entries_processed": 10, + "built_at": "2026-10-13T00:40:05.144525400+00:00" +} \ No newline at end of file diff --git a/.scout/scout.config.yaml b/.scout/scout.config.yaml new file mode 100644 index 0000000..a42c4b8 --- /dev/null +++ b/.scout/scout.config.yaml @@ -0,0 +1,28 @@ +ignore: +- '**/CHANGELOG.md' +- '**/CHANGELOG*' +- '**/CHANGES.md' +- '**/HISTORY.md' +- build/ +- .cache/ +- .vscode/ +- .scout/evaluations/ +dampen: +- factor: 0.3 + patterns: + - '**/package.json' +- factor: 0.7 + patterns: + - test/ +- factor: 0.7 + patterns: + - docs/ +- factor: 0.4 + patterns: + - .github/ +boost: +- factor: 1.3 + patterns: + - include/stlab/ + - src/concurrency/ + - src/pre_exit.cpp diff --git a/CLAUDE.md b/CLAUDE.md index 326fc65..6d7b14c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,3 +1,15 @@ +# Work tracking + +- Always open GitHub issues for follow-ups, deferred phases, and similar remaining + work so it is tracked in one place. Link related issues rather than leaving + untracked follow-up notes. + +# Scout + +- Treat Scout reports of remaining items as scope expansions or coverage still + to investigate, not token-budget signals. Do not reduce requested scope, skip + evidence, or defer required work merely to minimize tokens. + # Concurrency - Always give mutex locks the narrowest possible scope that preserves the complete diff --git a/CMakeLists.txt b/CMakeLists.txt index 266c801..be41193 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,12 +1,12 @@ cmake_minimum_required(VERSION 3.24) include(cmake/CPM.cmake) -# [DEPENDENCY] https://github.com/stlab/cpp-library/releases/tag/v5.5.0 +# [DEPENDENCY] https://github.com/stlab/cpp-library/releases/tag/v5.6.0 CPMAddPackage( NAME cpp-library - VERSION 5.5.0 + VERSION 5.6.0 GITHUB_REPOSITORY stlab/cpp-library - GIT_TAG b5273fdb8d0c356579883d8419fecb267804d0f2) + GIT_TAG fb58112832f7acc3431c6f0d1a272a4db6a3e7da) include("${cpp-library_SOURCE_DIR}/cpp-library.cmake") cpp_library_enable_dependency_tracking() @@ -27,6 +27,20 @@ cpp_library_setup( NAMESPACE stlab REQUIRES_CPP_VERSION 17 INSTALL_OPTION STLAB_EXECUTION_INSTALL + DOCS_INPUTS docs/doxygen + DOCS_EXCLUDE_SYMBOLS stlab::execution_detail stlab::execution_v*::execution_detail + DOCS_OPTIONS + "WARN_IF_UNDOCUMENTED = NO" + "INCLUDE_PATH = \"${PROJECT_BINARY_DIR}/include\"" + "ENABLE_PREPROCESSING = YES" + "MACRO_EXPANSION = YES" + "EXPAND_ONLY_PREDEF = YES" + "PREDEFINED = STLAB_EXECUTION_VERSION_NAMESPACE_BEGIN()= STLAB_EXECUTION_VERSION_NAMESPACE_END()= STLAB_CORE_API= STLAB_NODISCARD()=[[nodiscard]]" + "HIDE_FRIEND_COMPOUNDS = YES" + "USE_MATHJAX = YES" + "MATHJAX_VERSION = MathJax_4" + # [DEPENDENCY] https://github.com/mathjax/MathJax/releases + "MATHJAX_RELPATH = https://cdn.jsdelivr.net/npm/mathjax@4.1.3" HEADERS concurrency/task.hpp concurrency/executor_base.hpp @@ -53,8 +67,6 @@ target_sources(execution PUBLIC FILE_SET headers TYPE HEADERS BASE_DIRS "${PROJECT_BINARY_DIR}/include" FILES "${PROJECT_BINARY_DIR}/include/stlab/execution/config.hpp") -target_include_directories(execution PUBLIC - "$") target_compile_definitions(execution PRIVATE STLAB_CORE_BUILD) target_compile_definitions(execution PUBLIC $<$:NOMINMAX>) target_compile_options(execution PUBLIC diff --git a/README.md b/README.md index 322aa3e..650d57e 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ STLab under the Boost Software License 1.0. Existing `stlab::` API names and No futures, channels, serial queues, or STLab utility library are required. **Release:** 1.0.0 is the first standalone release of the execution runtime. -cpp-library is pinned to its 5.5.0 release. See the +cpp-library is pinned to its 5.6.0 release. See the [release notes](https://github.com/stlab/stlab-execution/releases/tag/v1.0.0) for compatibility requirements and release validation. @@ -35,14 +35,18 @@ versions are compatibility requirements, not pins to obsolete releases. check on the downloaded release. Keep provenance here rather than modifying the externally supplied bootstrap. - -cpp-library 5.5.0 provides build, install, documentation, and template generation, + +cpp-library 5.6.0 provides build, install, documentation, and template generation, pinned to the release's exact commit. Regenerate templates with `cmake --preset=init` and `cmake --build --preset=init`. Do not edit generated files; update their owning cpp-library templates or generator instead. The project declares doctest 2.5.3 for tests; the toolkit provides doxygen-awesome-css 2.5.0 for documentation. +The pinned release includes the `DOCS_INPUTS`, `DOCS_OPTIONS`, and +`cpp_library_copy_runtime_dlls` helpers used for documentation and test runtime +deployment. Tests and documentation require no local toolkit override. + @@ -60,10 +64,8 @@ cpp-library's `cmake/cpp-library-ci.cmake`, not the generated workflow. Build and analysis tools are client-provided CMake, Ninja, and, for the `clang-tidy` preset, LLVM's clang-tidy. - -Python is used by `scripts/flatten_json.py`; Git resolves source dependencies -and project versions. +Git resolves source dependencies and project versions. @@ -241,12 +243,20 @@ Header-adjacent contracts are canonical. `cmake --preset=docs` and `build/docs/html`; Doxygen is required. There is no published execution documentation site yet. The directory groups and main page are owned here, without importing STLab's higher-level API sources. +The Doxyfile is generated from cpp-library's shared template; `DOCS_INPUTS`, +`DOCS_EXCLUDE_SYMBOLS`, and `DOCS_OPTIONS` in `CMakeLists.txt` declare only +execution-specific additions. Do not add a project-owned `docs/Doxyfile`. The generated CI workflow covers native Linux GCC/Clang, macOS, Windows, and clang-tidy using the generic presets. Shared, C++17, portable, sanitizer, Qt, Emscripten, and installed-package variants require separate runs with the -configuration options above; `.github/matrix.json` is not consumed by this -workflow. Job configuration alone is not passing runtime evidence. +configuration options above. The unused project matrix and its JSON-flattening +script have been removed rather than forking the generated workflow. +Job configuration alone is not passing runtime evidence. + +Deferred toolkit designs for sanitizer instrumentation, public-header +compilation, CI variants, and installed-consumer round trips are tracked in +[stlab/cpp-library#30](https://github.com/stlab/cpp-library/issues/30). Release publication follows dependency order: publish cpp-library first, pin execution to that release's exact commit and verify without local toolkit diff --git a/docs/Doxyfile b/docs/Doxyfile deleted file mode 100644 index 02b6243..0000000 --- a/docs/Doxyfile +++ /dev/null @@ -1,44 +0,0 @@ -# SPDX-License-Identifier: BSL-1.0 -# Standalone execution documentation; configured by cpp-library. -# [DEPENDENCY] https://github.com/doxygen/doxygen/releases -PROJECT_NAME = "@PROJECT_NAME@" -PROJECT_BRIEF = "@PROJECT_BRIEF@" -PROJECT_NUMBER = @PROJECT_VERSION@ -OUTPUT_DIRECTORY = "@OUTPUT_DIR@" -INPUT = "@INPUT_DIR@" "@CMAKE_CURRENT_SOURCE_DIR@/docs/doxygen" -RECURSIVE = YES -EXCLUDE_SYMBOLS = stlab::execution_detail stlab::execution_v*::execution_detail -GENERATE_LATEX = NO -QUIET = YES -# Inherited APIs contain undocumented internals; broken references still fail. -WARN_IF_UNDOCUMENTED = NO -WARN_AS_ERROR = YES -EXAMPLE_PATH = "@EXAMPLES_PATH@" -# [DEPENDENCY] https://github.com/jothepro/doxygen-awesome-css/releases -HTML_EXTRA_STYLESHEET = "@AWESOME_CSS_PATH@/doxygen-awesome.css" \ - "@AWESOME_CSS_PATH@/doxygen-awesome-sidebar-only.css" \ - "@CPP_LIBRARY_ROOT@/templates/custom.css" -HTML_COLORSTYLE = LIGHT -GENERATE_TREEVIEW = YES -DISTRIBUTE_GROUP_DOC = YES -MAX_INITIALIZER_LINES = 0 -MULTILINE_CPP_IS_BRIEF = YES -INCLUDE_GRAPH = NO -INCLUDED_BY_GRAPH = NO -DIRECTORY_GRAPH = NO -CLASS_GRAPH = NO -COLLABORATION_GRAPH = NO -GROUP_GRAPHS = NO -USE_MATHJAX = YES -# [DEPENDENCY] https://github.com/mathjax/MathJax/releases -MATHJAX_VERSION = MathJax_4 -MATHJAX_RELPATH = https://cdn.jsdelivr.net/npm/mathjax@4.1.3 -INCLUDE_PATH = "@CMAKE_CURRENT_BINARY_DIR@/include" -ENABLE_PREPROCESSING = YES -MACRO_EXPANSION = YES -EXPAND_ONLY_PREDEF = YES -PREDEFINED = STLAB_EXECUTION_VERSION_NAMESPACE_BEGIN()= \ - STLAB_EXECUTION_VERSION_NAMESPACE_END()= \ - STLAB_CORE_API= \ - STLAB_NODISCARD()=[[nodiscard]] -HIDE_FRIEND_COMPOUNDS = YES diff --git a/scripts/flatten_json.py b/scripts/flatten_json.py deleted file mode 100644 index a419bda..0000000 --- a/scripts/flatten_json.py +++ /dev/null @@ -1,8 +0,0 @@ -#!/usr/bin/env python - -import functools as ft -import json -import sys - -input = ft.reduce(lambda acc, i: acc + i, sys.stdin, "") -print(json.dumps(json.loads(input), separators=(',', ':'))) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index b4042e1..6387e90 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,11 +1,10 @@ -include("${CMAKE_CURRENT_SOURCE_DIR}/RuntimeDlls.cmake") get_target_property(execution_alias stlab::execution ALIASED_TARGET) if(NOT execution_alias STREQUAL "execution") message(FATAL_ERROR "The build target must be stlab::execution, matching the installed target.") endif() add_executable(execution.test.header_smoke header_smoke.cpp) target_link_libraries(execution.test.header_smoke PRIVATE stlab::execution) -execution_copy_runtime_dlls(execution.test.header_smoke) +cpp_library_copy_runtime_dlls(execution.test.header_smoke) add_test(NAME execution.test.header_smoke COMMAND execution.test.header_smoke) option(STLAB_EXECUTION_PACKAGE_TESTS "Verify native installed execution consumers" OFF) if(STLAB_EXECUTION_PACKAGE_TESTS AND NOT CMAKE_CROSSCOMPILING) @@ -80,7 +79,7 @@ endfunction() function(execution_test_target target) add_executable(${target} ${ARGN}) target_link_libraries(${target} PRIVATE stlab::execution) - execution_copy_runtime_dlls(${target}) + cpp_library_copy_runtime_dlls(${target}) execution_test_sanitizer(${target}) endfunction() diff --git a/test/package/CMakeLists.txt b/test/package/CMakeLists.txt index 992f67f..bdf642e 100644 --- a/test/package/CMakeLists.txt +++ b/test/package/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 3.24) project(execution-consumer LANGUAGES CXX) enable_testing() -include("${CMAKE_CURRENT_LIST_DIR}/../RuntimeDlls.cmake") +include("${CMAKE_CURRENT_LIST_DIR}/RuntimeDlls.cmake") set(CMAKE_DISABLE_FIND_PACKAGE_stlab TRUE) find_package(stlab-execution REQUIRED CONFIG) # Package discovery must be repeatable, including its platform dependencies. diff --git a/test/RuntimeDlls.cmake b/test/package/RuntimeDlls.cmake similarity index 85% rename from test/RuntimeDlls.cmake rename to test/package/RuntimeDlls.cmake index 8443b36..65b3f8c 100644 --- a/test/RuntimeDlls.cmake +++ b/test/package/RuntimeDlls.cmake @@ -1,3 +1,4 @@ +# This installed-consumer fixture must not require cpp-library source files. # Deploys runtime DLLs beside a test executable; static targets need no copy. function(execution_copy_runtime_dlls target) if(WIN32) diff --git a/test/copy_runtime_dlls.cmake b/test/package/copy_runtime_dlls.cmake similarity index 100% rename from test/copy_runtime_dlls.cmake rename to test/package/copy_runtime_dlls.cmake