das2rst.das

options gen2
options rtti = true
// docs describe the SOURCE API: splices legitimately rewrite ctor bodies, method
// shapes, and describe() output, which would rename hash-keyed doc files per run
options auto_inline_functions = false

require daslib/fio
require clipboard/clipboard
require daslib/rtti
require daslib/ast
require math
require uriparser
require strings
require jobque
require daslib/ast_boost
require daslib/strings_boost
require daslib/strings_convert
require daslib/md_boost
require daslib/rst
require daslib/rst_comment
require daslib/functional
require daslib/json
require daslib/json_boost
require daslib/jsonrpc
require daslib/regex
require daslib/regex_boost
require daslib/apply
require daslib/algorithm
require daslib/ansi_colors
require daslib/tty
require daslib/jobque_boost
require daslib/jobque_profile
require daslib/apply_in_context
require daslib/contracts
require daslib/defer
require daslib/with_boost
require daslib/delegate
require daslib/option
require daslib/result
require daslib/if_not_null
require daslib/templates
require daslib/templates_boost
require daslib/instance_function
require daslib/is_local
require daslib/safe_addr
require daslib/static_let
require daslib/lpipe
require daslib/random
require daslib/math_bits
require daslib/math_boost
require daslib/array_boost
require daslib/archive
require daslib/unroll
require daslib/assert_once
require daslib/ast_block_to_loop
require daslib/ast_cursor
require daslib/ast_match
require daslib/ast_used
require daslib/constant_expression
require daslib/uriparser_boost
require daslib/sort_boost
require daslib/enum_trait
require daslib/cpp_bind
require daslib/decs
require daslib/decs_boost
require daslib/utf8_utils
require daslib/coroutines
require daslib/interfaces
require daslib/faker
require daslib/fuzzer
require daslib/match
require daslib/linq
require daslib/linq_boost
require daslib/linq_fold
require daslib/flat_hash_table
require daslib/cuckoo_hash_table
require daslib/macro_boost
require daslib/class_boost
require daslib/soa
require daslib/base64
// require daslib/linked_list                  // spoof template, not documentable
require daslib/bool_array
require daslib/bitfield_boost
require daslib/bitfield_trait
require daslib/async_boost
require daslib/command_line
require daslib/consume
require daslib/dap
require daslib/das_source_formatter
require daslib/das_source_formatter_fio
// require daslib/debug                          // uses persistent_heap, gc, complex dependencies
require daslib/debug_eval
require daslib/decs_state
require daslib/dynamic_cast_rtti
require daslib/generic_return
// require daslib/heartbeat                     // qmacro(heartbeat()) conflicts when used in das2rst context
require daslib/lint
require daslib/logger
// require daslib/lint_everything               // global_lint_macro causes lint errors in other modules
require daslib/profiler
require daslib/profiler_boost
require daslib/quote
require daslib/refactor
require daslib/remove_call_args
// require daslib/spoof                           // depends on peg module
require daslib/stringify
require peg/peg
require gltf/gltf_boost
require daslib/temp_strings
require daslib/type_traits
require daslib/typemacro_boost
require daslib/validate_code
require dashv/dashv_boost
require openai/openai_common
require openai/openai_chat
require openai/openai_embeddings
require openai/openai_models
require openai/openai_completions
require openai/openai_audio
require openai/openai_moderations
require openai/openai_images
require openai/openai_vision
require pugixml/PUGIXML_boost
require stbimage/stbimage_boost
require stbimage/stbimage_ttf
require audio/audio_boost
require audio/audio_wav
require audio/audio_record
require strudel/strudel_event
require strudel/strudel_time
require strudel/strudel_live
require strudel/strudel_scales
require strudel/strudel_mini
require strudel/strudel_samples
require strudel/strudel_synth
require strudel/strudel_scheduler
require strudel/strudel_player
require strudel/strudel_midi
require strudel/strudel_midi_player
require strudel/strudel_sf2
require strudel/strudel_sf2_voice
require strudel/strudel_pattern
require spirv/spirv_reflect
require dasllama/dasllama
require llvm/daslib/llvm_tune   // documentation context keeps [tune] fully inert

def document_module_math(_root : string) {
    var mod = get_module("math")
    var groups <- array<DocGroup>(
        group_by_regex("Horizontal reduce (float2, float3, float4)", mod, %regex~(hmin|hmax|hadd)$%%),
        group_by_regex("all numerics (uint*, int*, float*, double)", mod, %regex~(min|max)$%%),
        group_by_regex("float* and double", mod, %regex~(sign|abs|acos|asin|safe_acos|safe_asin|atan|atan2|cos|sin|tan|sinh|cosh|tanh|asinh|acosh|atanh|exp|log|exp2|expm1|log2|log10|log1p|pow|sqrt|cbrt|hypot|fmod|remainder|trunc|rcp|ceil|floor|abs|saturate|sincos|is_finite|is_nan|radians|degrees|step|smoothstep)$%%),
        group_by_regex("float* only", mod, %regex~(atan_est|atan2_est|rcp_est|ceili|floori|roundi|trunci|round|rsqrt|rsqrt_est|fract|\-)$%%),
        group_by_regex("float3 only", mod, %regex~(cross|reflect|refract|distance|distance_sq|
inv_distance|inv_distance_sq)$%%),
        group_by_regex("float2, float3, float4", mod, %regex~(length|length_sq|inv_length|inv_length_sq|
dot|normalize|fast_normalize)$%%),
        group_by_regex("Noise functions", mod, %regex~(uint32_hash|uint_noise_1D|uint_noise_2D|uint_noise_3D)$%%),
        group_by_regex("lerp/mad/clamp", mod, %regex~(lerp|mad|clamp)$%%),
        group_by_regex("Matrix element access", mod, %regex~\.\[\]$%%),
        group_by_regex("Matrix operations", mod, %regex~(\=\=|\!\=|\*).*$%%),
        group_by_regex("Matrix initializers", mod, %regex~(float3x4|float4x4|float3x3|identity3x4|identity4x4|identity3x3)$%%),
        group_by_regex("Matrix manipulation", mod, %regex~(identity|inverse|rotate|transpose|translation|compose|decompose|look_at|orthonormal_inverse|persp_forward|persp_reverse|determinant)$%%),
        group_by_regex("Quaternion operations", mod, %regex~(quat_conjugate|quat_mul|quat_mul_vec|quat_from_unit_arc|quat_from_unit_vec_ang|quat_from_euler|euler_from_quat|quat$|quat_slerp)%%),
        group_by_regex("Packing and unpacking", mod, %regex~(pack_float_to_byte|unpack_byte_to_float)$%%)
    );
    document("Math library", mod, "math.rst", groups);
}

def document_module_builtin(_root : string) {
    var mod = [get_module("$"), find_module("builtin")]
    var groups <- array<DocGroup>(
        hide_group(group_by_regex("Internal builtin functions", mod, %regex~builtin%%)),
        hide_group(group_by_regex("Internal pointer arithmetics", mod, %regex~i_das_%%)),
        hide_group(group_by_regex("Internal clone infrastructure", mod, %regex~clone%%)),
        hide_group(group_by_regex("Internal finalize infrastructure", mod, %regex~finalize%%)),
        group_by_regex("Containers", mod, %regex~(capacity|clear|length|resize|resize_no_init|reserve|each|each_kv|emplace|emplace_from|erase|find|
find_for_edit|find_if_exists|find_index|find_index_if|has_value|key_exists|keys|values|get_key|lock|each_enum|each_ref|
find_for_edit_if_exists|lock_forever|next|nothing|pop|push|push_from|push_clone|push_clone_from|back|sort|stable_sort|to_array|to_table|to_array_move|
to_table_move|empty|subarray|insert|move_to_ref|copy_to_local|move_to_local|get|remove_value|erase_if|resize_and_init|
get_value|insert_clone|emplace_new|insert_default|emplace_default|get_with_default|modify|long_length|long_capacity|long_find_index)$%%),
        group_by_regex("Character set groups", mod, %regex~(is_alpha|is_number|is_white_space|is_char_in_set)$%%),
        group_by_regex("das::string manipulation", mod, %regex~(peek|set)$%%),
        group_by_regex("String builder", mod, %regex~(build_string|write|write_char|write_chars|write_escape_string)$%%),
        group_by_regex("Heap reporting", mod, %regex~(heap|string_heap|memory_report|tag_array|tag_table)%%),
        group_by_regex("Vector and matrix math", mod, %regex~(float3x4|float4x4|identity|inverse|rotate|translation|transpose)$%%),
        group_by_regex("16/8-bit lattice converts", mod, %regex~(short2_sat|short3_sat|short4_sat|ushort2_sat|ushort3_sat|ushort4_sat|byte2_sat|byte3_sat|byte4_sat|byte8_sat|ubyte2_sat|ubyte3_sat|ubyte4_sat|ubyte8_sat|half8_lo|half8_hi)$%%),
        group_by_regex("16/8-bit lattice integer dots", mod, %regex~(idot|idot4|shuffle)$%%),
        group_by_regex("GC0 infrastructure", mod, %regex~gc0%%),
        group_by_regex("Smart ptr infrastructure", mod, %regex~(add_ptr_ref|smart_ptr|get_const_ptr|move|move_new|get_ptr$)%%),
        group_by_regex("Macro infrastructure", mod, %regex~(is_folding|is_compiling|is_in_completion|is_in_lint_check|is_building_documentation|is_reporting_compilation_errors)%%),
        group_by_regex("Profiler", mod, %regex~(profile|reset_profiler|dump_profile_info|collect_profile_info)$%%),
        group_by_regex("System infrastructure", mod, %regex~(panic|print|feint|sprint|sprint_json|sscan_json|to_log|to_compiler_log|error|terminate|breakpoint|stackwalk|get_stackwalk|get_das_root|get_das_version|is_in_aot|aot_enabled|is_intern_strings|is_safe_hash|eval_main_loop|shared_module_extension)$%%),
        group_by_regex("Memory manipulation", mod, %regex~(intptr|memcmp|variant_index|set_variant_index|hash|memcpy|lock_data|map_to_array|map_to_ro_array)$%%),
        group_by_regex("Binary serializer", mod, %regex~(binary_load|binary_save)$%%),
        group_by_regex("Path and command line", mod, %regex~(get_command_line_arguments|with_argv)$%%),
        group_by_regex("Time and date", mod, %regex~(get_time_usec|ref_time_ticks|get_clock|get_time_nsec|mktime|iso8601_now|format_time)$%%),
        group_by_regex("Platform queries", mod, %regex~(get_context_share_counter|das_is_dll_build|das_is_exceptions_enabled|is_standalone_exe|get_platform_name|get_running_platform_name|get_cross_platform_name|get_architecture_name|cpu_supports)$%%),
        group_by_regex("String formatting", mod, %regex~(fmt)$%%),
        group_by_regex("Argument consumption", mod, %regex~(consume_argument)$%%),
        group_by_regex("Lock checking", mod, %regex~(lock_count)$%%),
        group_by_regex("Bit operations", mod, %regex~(popcnt|clz|ctz|mul128|__bit_set)$%%),
        group_by_regex("Intervals", mod, %regex~(interval)$%%),
        group_by_regex("RTTI", mod, %regex~(class_rtti_size)$%%),
        hide_group(group_by_regex("Jit", mod,%regex~(invoke_code|.*jit.*)$%%)),
        group_by_regex("Initialization and finalization", mod, %regex~(using|clone|finalize)$%%),
        group_by_regex("Algorithms", mod, %regex~(swap|iter_range|count|ucount|long_iter_range)$%%),
        group_by_regex("Memset", mod, %regex~(memset.*)$%%),
        group_by_regex("Malloc", mod, %regex~(malloc|free|malloc_usable_size)$%%),
        group_by_regex("Compilation and AOT", mod, %regex~(is_aot_enabled|set_aot|reset_aot|compiling_file_name|compiling_module_name|get_module_file_name)$%%),
        group_by_regex("GC", mod, %regex~(gc_active_root_count|gc_thread_root_count|gc_thread_root_report|gc_thread_root_report_detailed|gc_total_id)$%%))
    documents("Built-in runtime", mod, "builtin.rst", groups);
}

def document_module_fio(_root : string) {
    var mod = [get_module("fio_core"), find_module("fio")]
    var groups <- array<DocGroup>(
        hide_group(group_by_regex("Internal builtin functions", mod, %regex~builtin%%)),
        group_by_regex("File manipulation", mod, %regex~(f|long_f|stat$|getchar|remove|rename|copy_file|file_size|equivalent|is_symlink|set_mtime)%%),
        group_by_regex("Path manipulation", mod, %regex~(base_name|dir_name|get_full_file_name|extension|stem|replace_extension|path_join|normalize|to_generic_path|is_absolute|relative|relative_result|parent)$%%),
        group_by_regex("Directory manipulation", mod, %regex~(dir|dir_rec|mkdir|mkdir_rec|mkdir_result|rmdir|rmdir_rec|rmdir_rec_result|rmdir_result|chdir|getcwd)$%%),
        group_by_regex("Glob and pattern matching", mod, %regex~(match_glob|glob|glob_filtered|is_glob_pattern|expand_glob|parse_file_list)$%%),
        group_by_regex("Filesystem queries", mod, %regex~(temp_directory|temp_directory_result|create_temp_file|create_temp_file_result|create_temp_directory|create_temp_directory_result|disk_space)$%%),
        group_by_regex("Terminal queries", mod, %regex~(is_terminal|terminal_width)$%%),
        group_by_regex("OS specific routines", mod, %regex~(sleep|exit|system|popen|popen_binary|popen_timeout|spawn_argv|popen_argv|popen_argv_pipe|popen_timed_out|run_and_capture|get_env_variable|set_env_variable|sanitize_command_line|has_env_variable)$%%),
        group_by_regex("Dynamic modules", mod, %regex~(register_dynamic_module|register_native_path)$%%)
    )
    documents("File input output library", mod, "fio.rst", groups)
}

def document_module_clipboard(_root : string) {
    var mod = [get_module("clipboard_core"), find_module("clipboard")]
    var groups <- array<DocGroup>(
        hide_group(group_by_regex("Internal clipboard functions", mod, %regex~^_clipboard_%%)),
        group_by_regex("UTF-8 system clipboard", mod, %regex~^clipboard_%%)
    )
    documents("System clipboard", mod, "clipboard.rst", groups)
}

def document_module_random(_root : string) {
    var mod = get_module("random")
    var groups <- array<DocGroup>(
        group_by_regex("Seed and basic generators", mod, %regex~(random_seed|random_seed2D|random_float|random_float4|random_int|random_big_int|random_int4|random_uint)$%%),
        group_by_regex("Random iterators", mod, %regex~(each_random_.*)$%%),
        group_by_regex("Specific distributions", mod, %regex~(random_unit_vector|random_in_unit_disk|random_in_unit_sphere)$%%)
    )
    document("Random generator library", mod, "random.rst", groups)
}

def document_module_network(_root : string) {
    var mod = get_module("network_core")
    var groups <- array<DocGroup>(
        group_by_regex("Low level NetworkServer IO", mod, %regex~(make_server|server_init|server_is_open|server_is_connected|server_tick|server_send|server_restore)$%%)
    )
    document("Network socket library", mod, "network.rst", groups)
}

def document_module_dashv(_root : string) {
    var mod = get_module("dashv")
    var groups <- array<DocGroup>(
        group_by_regex("WebSocket client", mod, %regex~(make_web_socket_client|destroy_web_socket_client|open|close|is_connected|tick|send)$%%),
        group_by_regex("WebSocket server lifecycle", mod, %regex~(make_web_socket_server|destroy_web_socket_server|set_bind_host|start|stop)$%%),
        group_by_regex("WebSocket channel send", mod, %regex~(send)$%%),
        group_by_regex("Handle operations", mod, %regex~(is_alive|==|!=)$%%),
        group_by_regex("HTTP route registration", mod, %regex~(GET|POST|PUT|DELETE|PATCH|HEAD|ANY|SSE|STREAM)$%%),
        group_by_regex("HTTP server configuration", mod, %regex~(STATIC|allow_cors|set_document_root|set_home_page|set_index_of|set_error_page)$%%),
        group_by_regex("HTTP response helpers", mod, %regex~(TEXT_PLAIN|JSON|REDIRECT|SERVE_FILE|DATA|set_header|set_content_type)$%%),
        group_by_regex("HTTP client requests", mod, %regex~(request|request_cb|status_message)$%%),
        group_by_regex("Message and header access", mod, %regex~(get_header|each_header|.*content_length)$%%),
        group_by_regex("Request configuration", mod, %regex~(set_basic_auth|set_bearer_token_auth|set_timeout|set_connect_timeout|allow_redirect|set_param|get_param|each_param)$%%),
        group_by_regex("Cookies", mod, %regex~(add_cookie|get_cookie|each_cookie)$%%),
        group_by_regex("Form data", mod, %regex~(set_form_data|set_form_file|get_form_data|each_form_field|save_form_file|set_url_encoded|get_url_encoded)$%%),
        group_by_regex("SSE response writer", mod, %regex~(respond|sse_event|end_headers|write_chunked|set_writer_keepalive_timeout|close_writer|release_writer|is_writer_connected)$%%)
    )
    document("HTTP and WebSocket library (libhv)", mod, "dashv.rst", groups)
}

def document_module_dashv_boost(_root : string) {
    var mod = find_module("dashv_boost")
    var groups <- array<DocGroup>(
        group_by_regex("HTTP request helpers", mod, %regex~(with_http_request|get_body_bytes)$%%)
    )
    document("High-level HTTP and WebSocket wrappers", mod, "dashv_boost.rst", groups)
}

def document_module_openai(_root : string) {
    var mod = [find_module("openai_common"), find_module("openai_chat"),
        find_module("openai_embeddings"), find_module("openai_models"),
        find_module("openai_completions"), find_module("openai_audio"),
        find_module("openai_moderations"), find_module("openai_images"),
        find_module("openai_vision")]
    var groups <- array<DocGroup>(
        group_by_regex("Client and transport", mod, %regex~(openai_client|configure_request|percent_encode|parse_error_body|post_json|get_json|post_for_bytes|post_and_decode|get_and_decode)$%%),
        group_by_regex("Chat completions", mod, %regex~(chat|chat_text|chat_stream|json_object_format)$%%),
        group_by_regex("Embeddings", mod, %regex~(embeddings|embed)$%%),
        group_by_regex("Models", mod, %regex~(list_models|retrieve_model)$%%),
        group_by_regex("Legacy completions", mod, %regex~(completions|complete)$%%),
        group_by_regex("Audio (TTS and STT)", mod, %regex~(speech|speak|transcribe|translate)$%%),
        group_by_regex("Moderations", mod, %regex~(moderations)$%%),
        group_by_regex("Image generation", mod, %regex~(generate_image)$%%),
        group_by_regex("Vision", mod, %regex~(chat_vision|vision_request_body)$%%)
    )
    documents("OpenAI-compatible API client (chat, embeddings, audio, vision, ...)", mod, "openai.rst", groups)
}

// One hand-written stanza per engine type the facade signatures mention. The facade re-exports
// these from dasllama_common / dasllama_chat, which are deliberately NOT documented (their
// internals are engine detail) — the stanzas define the :ref: labels the signatures link to.
def private dasllama_type_stanza(f : FILE const?; lab : string; tname : string; text : string) {
    fwrite(f, ".. _{lab}:\n\n")
    fwrite(f, ".. das:attribute:: {tname}\n\n")
    fwrite(f, "{text}\n\n")
}

def document_module_dasllama(_root : string) {
    var mod = find_module("dasllama")
    var groups <- array<DocGroup>(
        group_by_regex("Model loading and sessions", mod, %regex~(load_model|create_session|create_kv_pool|release_kv_pages|create_batch_workspace|setup_dasllama_jobque|caps)$%%),
        group_by_regex("Prefix cache", mod, %regex~(create_prefix_cache|prefix_attach|prefix_insert|prefix_release|prefix_held_groups|prefix_chain_list)$%%),
        group_by_regex("Tokenizer", mod, %regex~(encode|decode|piece)$%%),
        group_by_regex("Evaluation and sampling", mod, %regex~(eval|eval_embd|eval_batch|sample|set_seed|stats)$%%),
        group_by_regex("Generation", mod, %regex~(generate|generate_embd)$%%),
        group_by_regex("Embeddings", mod, %regex~(embed)$%%),
        group_by_regex("Chat", mod, %regex~(create_chat|create_chat_renderer|add_user|add_user_audio|add_assistant|render_turn|render_assistant|render_close|respond|set_thinking)$%%),
        group_by_regex("Tool calling", mod, %regex~(set_tools|add_tool_results|render_assistant_calls)$%%)
    )
    var hook = DocsHook()
    hook.afterEnums <- @(var f : FILE const?; _was_enums : bool) {
        fwrite(f, make_group("Types"))
        fwrite(f, "The engine types the API below works with. They are created and consumed by the\n")
        fwrite(f, "functions of this module; their remaining fields are engine implementation detail.\n\n")
        dasllama_type_stanza(f, "struct-dasllama_common-Model", "Model",
            "A loaded model: weights, ``config``, tokenizer, and the architecture's blocks and chat template, as produced by ``load_model``. User code touches ``config`` (e.g. cap ``config.seq_len`` before ``create_session`` on large-context models) and ``arch`` (the GGUF architecture name).")
        dasllama_type_stanza(f, "struct-dasllama_common-Session", "Session",
            "One generation stream over a model: the KV cache, scratch buffers, sampling RNG, and the current position ``n_past``. ``logits`` holds the distribution produced by the last ``eval``. A model serves many independent sessions.")
        dasllama_type_stanza(f, "struct-dasllama_common-BatchWorkspace", "BatchWorkspace",
            "Caller-owned scratch for ``eval_batch``: the batched activation buffers a step of B sessions shares. One per concurrent batch, reused across calls; holds no session state — positions, caches and logits stay in the sessions.")
        dasllama_type_stanza(f, "struct-dasllama_common-KVPool", "KVPool",
            "A caller-owned paged KV-cache pool (``create_kv_pool``): sessions created over it allocate fixed-size page groups on demand, so cache memory tracks the actual context instead of the full ``seq_len`` slab. One pool serves many sessions; an ``eval_batch`` batch must share one pool. Keep it alive and in place while its sessions live.")
        dasllama_type_stanza(f, "struct-dasllama_prefix-PrefixCache", "PrefixCache",
            "A page-granular prefix cache over one pool's sessions (``create_prefix_cache``): finished streams donate their KV pages keyed by a chained page hash of the token history, and later requests attach the longest cached prefix instead of re-prefilling it. Pages are refcounted with the pool; an LRU budget bounds retention.")
        dasllama_type_stanza(f, "enum-dasllama_common-KVDtype", "KVDtype",
            "Per-session KV-cache codec picked at ``create_session``/``create_chat``: ``f16`` — the default, half the KV bytes and faster deep-context decode (stores clamp to ±65504); ``f32`` — the bit-exact reference; ``q8_0`` — block-quantized (llama.cpp ``-ctk``/``-ctv q8_0``), half the f16 bytes again and near-lossless in practice; needs head_size and kv_dim to be multiples of 32 (checked at create).")
        dasllama_type_stanza(f, "enum-dasllama_common-QuantMode", "QuantMode",
            "Weight representation picked at load: ``fp32`` — the token-exact reference; ``q8`` — int8 quantization, the fast CPU path; ``q4`` — 4-bit, smallest footprint.")
        dasllama_type_stanza(f, "struct-dasllama_common-SamplingParams", "SamplingParams",
            "Sampling knobs: ``temp`` (<= 0 selects greedy argmax), ``top_k`` (0 = no cutoff), and repetition ``penalty`` (1.0 = none) applied over the last ``penalty_last_n`` generated tokens. The defaults are greedy — ``SamplingParams()`` reproduces argmax exactly.")
        dasllama_type_stanza(f, "struct-dasllama_common-Stats", "Stats",
            "Timing of the last ``generate``/``respond`` call: ``n_prompt``/``n_gen`` token counts, ``ttft_s`` (seconds to first token), and ``prefill_tps``/``gen_tps`` throughput in tokens per second.")
        dasllama_type_stanza(f, "struct-dasllama_common-LlmCaps",  "LlmCaps",
            "What the model honestly supports at the chat layer, as returned by ``caps``: ``system_prompt`` is false for architectures with no system role (gemma), where the chat layer silently folds the system prompt into the first user turn. Grows as gaps surface.")
        dasllama_type_stanza(f, "struct-dasllama_chat-ChatSession", "ChatSession",
            "A conversation over a model: its ``session``, the resolved chat template, and the running transcript in ``history``. Create with ``create_chat``, then drive with ``add_user`` + ``respond``.")
        dasllama_type_stanza(f, "struct-dasllama_audio-AudioTower", "AudioTower",
            "A loaded audio encoder: Whisper-family encoder weights plus the model-specific projector tail, as produced by ``load_audio_tower`` from an mmproj GGUF. Pass it to ``create_chat`` to enable ``add_user_audio`` turns.")
    }
    document("dasLLAMA LLM inference: models, sessions, generation, chat", mod, "dasllama.rst", groups, hook)
}

def document_module_debugapi(_root : string) {
    var mod = get_module("debugapi")
    var groups <- array<DocGroup>(
        group_by_regex("Agent lifecycle", mod, %regex~(fork_debug_agent_context|install_debug_agent|install_debug_agent_thread_local|install_new_debug_agent|install_new_thread_local_debug_agent|has_debug_agent_context|get_debug_agent_context|delete_debug_agent_context|is_in_debug_agent_creation|lock_debug_agent)$%%),
        group_by_regex("Cross-context invocation", mod, %regex~(invoke_in_context|invoke_debug_agent_method|invoke_debug_agent_function)$%%),
        group_by_regex("Agent construction", mod, %regex~(make_debug_agent|make_data_walker|make_stack_walker)$%%),
        group_by_regex("Agent tick and state collection", mod, %regex~(tick_debug_agent|collect_debug_agent_state|on_breakpoints_reset|report_context_state|debug_agent_command|debugger_stop_requested)$%%),
        group_by_regex("Instrumentation", mod, %regex~(instrument_node|instrument_function|instrument_all_functions|instrument_all_functions_thread_local|instrument_context_allocations|clear_instruments|set_single_step)$%%),
        group_by_regex("Data and stack walking", mod, %regex~(walk_data|walk_stack|stackwalk|get_stackwalk|stack_depth)$%%),
        group_by_regex("Context inspection", mod, %regex~(get_context_global_variable|has_function|get_heap_stats)$%%),
        group_by_regex("Breakpoints", mod, %regex~(set_hw_breakpoint|clear_hw_breakpoint)$%%),
        group_by_regex("Memory", mod, %regex~(free_temp_string|temp_string_size|break_on_free|track_insane_pointer)$%%)
    )
    document("Debug agent API", mod, "debugapi.rst", groups)
}

def document_module_uriparser(_root : string) {
    var mod = get_module("uriparser")
    var groups <- array<DocGroup>(
        group_by_regex("Initialization and finalization", mod, %regex~(Uri|using|clone|finalize)$%%),
        group_by_regex("Escape and unescape", mod, %regex~(escape_uri|unescape_uri)$%%),
        group_by_regex("Uri manipulations", mod, %regex~(normalize_uri|unescape_uri|string|uri_for_each_query_kv|remove_base_uri|add_base_uri|strip_uri|normalize)$%%),
        group_by_regex("File name conversions", mod, %regex~(to_unix_file_name|to_windows_file_name|to_file_name|uri_from_file_name|uri_from_windows_file_name|uri_from_unix_file_name|uri_to_unix_file_name|uri_to_windows_file_name|unix_file_name_to_uri|windows_file_name_to_uri|uri_to_file_name|file_name_to_uri)$%%),
        group_by_regex("GUID", mod, %regex~(make_new_guid)$%%)
    )
    document("URI manipulation library based on UriParser", mod, "uriparser.rst", groups)
}

def document_module_rtti(_root : string) {
    var mod = [get_module("rtti_core"), find_module("rtti")]
    var groups <- array<DocGroup>(
        group_by_regex("Initialization and finalization", mod, %regex~(using|LineInfo|CodeOfPolicies|RttiValue_nothing)$%%),
        group_by_regex("Type access", mod, %regex~(get_dim|builtin_is_same_type|is_compatible_cast|get_das_type_name|is_same_type|each_dim|arg_types|arg_names|get_type_size|get_type_align)$%%),
        group_by_regex("Rtti context access", mod, %regex~(get_total_functions|get_total_variables|get_function_info|get_variable_info|get_variable_value|get_function_by_mnh|get_line_info|this_context|context_for_each_function|context_for_each_variable|class_info|type_info)$%%),
        group_by_regex("Program access", mod, %regex~(program_for_each_module|program_for_each_registered_module|get_this_module|get_module|has_module)$%%),
        group_by_regex("Module access", mod, %regex~(module_for_each_structure|module_for_each_enumeration|module_for_each_function|module_for_each_generic|module_for_each_global|module_for_each_annotation|module_for_each_dependency)$%%),
        group_by_regex("Annotation access", mod, %regex~(get_annotation_argument_value|add_annotation_argument|get_annotation|get_annotation_argument|resolve_annotation|each_annotation|each_annotation_argument)$%%),
        group_by_regex("Compilation and simulation", mod, %regex~(compile|compile_file|for_each_expected_error|for_each_require_declaration|simulate|create_ast_serializer|create_ast_deserializer|delete_ast_serializer|serialize_program|deserialize_program|ast_serializer_get_data)$%%),
        group_by_regex("File access", mod, %regex~(make_file_access|set_file_source|add_file_access_root|add_extra_module)$%%),
        group_by_regex("Structure access", mod, %regex~(rtti_builtin_structure_for_each_annotation|basic_struct_for_each_field|structure_for_each_annotation|basic_struct_for_each_parent)$%%),
        group_by_regex("Data walking and printing", mod, %regex~(sprint_data|sprint_json_at|sscan_json_at|describe|get_mangled_name)$%%),
        group_by_regex("Function and mangled name hash", mod, %regex~(get_function_by_mangled_name_hash|get_function_mangled_name_hash|get_function_address)$%%),
        group_by_regex("Context and mutex locking", mod, %regex~(lock_this_context|lock_context|lock_mutex)$%%),
        group_by_regex("Runtime data access", mod, %regex~(get_table_key_index)$%%),
        group_by_regex("Tuple and variant access", mod, %regex~(get_tuple_field_offset|get_variant_field_offset)$%%),
        group_by_regex("Lint suppression", mod, %regex~(rtti_get_source_line|rtti_is_nolint_suppressed|is_lint_suppressed|extract_lint_code)$%%),
        group_by_regex("Iteration", mod, %regex~(each)$%%))
    // CompilationError's 580-value list blows the search crawler's per-record size cap;
    // exclude it from search (the symbol + its description stay indexed).
    documents("Runtime type information library", mod, "rtti.rst", groups, DocsHook(), ["CompilationError"])
}

def document_module_ast(_root : string) {
    var mod = [get_module("ast_core"), find_module("ast")]
    var groups <- array<DocGroup>(
        group_by_regex("Compilation and file access", mod, %regex~(compile|compile_file|make_file_access)$%%),
        group_by_regex("Call generation", mod, %regex~(make_call)$%%),
        group_by_regex("Visitor pattern", mod, %regex~visit.*%%),
        group_by_regex("Expression generation", mod, %regex~(force_generated|get_expression_annotation|make_type_info_structure)%%),
        group_by_regex("Adapter generation", mod, %regex~make_.*%%),
        group_by_regex("Adapter application", mod, %regex~(add_.*_(annotation|macro)|add_new_comment_reader|add_comment_reader|add_module_option)%%),
        group_by_regex("Adding objects to objects", mod, %regex~add_.*%%),
        group_by_regex("Program and module access", mod, %regex~(this_program|this_module|compiling_program|compiling_module)$%%),
        group_by_regex("Textual descriptions of the objects", mod, %regex~(describe.*|das_to_string)%%),
        group_by_regex("Searching", mod, %regex~find.*%%),
        group_by_regex("Iterating", mod, %regex~(for_each.*|.*_foreach)%%),
        group_by_regex("Cloning", mod, %regex~clone.*%%),
        group_by_regex("Mangled name", mod, %regex~(parse_mangled_name|get_mangled_name)%%),
        group_by_regex("Size and offset", mod, %regex~.*_(size|offset)%%),
        group_by_regex("Pointer conversion", mod, %regex~(ExpressionPtr|FunctionPtr|StructurePtr)%%),
        group_by_regex("Evaluations", mod, %regex~(eval_single_expression)%%),
        group_by_regex("Error reporting", mod, %regex~(macro_error|macro_performance_warning|macro_style_warning)%%),
        group_by_regex("Location and context", mod, %regex~(force_at|collect_dependencies|get_ast_context)%%),
        group_by_regex("Use queries", mod, %regex~(get_use_global_variables|get_use_functions)%%),
        group_by_regex("Log", mod, %regex~(to_compilation_log)%%),
        group_by_regex("Removal", mod, %regex~(remove.*)%%),
        group_by_regex("Properties", mod, %regex~(is|has|get|can)_.*%%),
        group_by_regex("Infer", mod, %regex~(infer_generic_type|update_alias_map)$%%),
        group_by_regex("Module queries", mod, %regex~(module_find_annotation|module_find_type_annotation|module_find_structure|module_find_enumeration|module_has_comment_reader|not_inferred)$%%),
        group_by_regex("Debug info helpers", mod, %regex~(debug_helper_.*)%%),
        group_by_regex("AOT support", mod, %regex~(aot_require|aot_type_ann_get_field_ptr|aot_need_type_info|aot_previsit_get_field_ptr|aot_previsit_get_field|aot_visit_get_field|write_aot_body|write_aot_suffix|write_aot_macro_suffix|write_aot_macro_prefix|macro_aot_infix|getInitSemanticHashWithDep|get_aot_hash_comment)$%%),
        group_by_regex("String builder writer", mod, %regex~(string_builder_str|string_builder_clear)$%%),
        group_by_regex("GC", mod, %regex~(ast_gc_guard|ast_gc_collect_scope|verify_typedecl_gc|verify_expression_gc|delete_expression|delete_type)$%%),
        hide_group(group_by_regex("Internal ast infrastructure", mod, %regex~(builtin_ast_.*)%%))
    )
    documents("AST manipulation library", mod, "ast.rst", groups)
}

def document_module_ast_boost(_root : string) {
    var mod = find_module("ast_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Containers", mod, %regex~(emplace_new)%%),
        group_by_regex("Textual descriptions of the objects", mod, %regex~(describe.*|debug_expression)%%),
        group_by_regex("Queries", mod, %regex~(is.*|find.*|get.*)%%),
        group_by_regex("Annotations", mod, %regex~(append.*|add.*)%%),
        group_by_regex("Expression generation", mod, %regex~(override_method|panic_expr_as|make_static_assert_false|convert_to_expression)%%),
        group_by_regex("Visitors", mod, %regex~(visit.*)%%),
        group_by_regex("Type generation", mod, %regex~(function_to_type|make_fixed_array_type)%%),
        group_by_regex("Type casts", mod, %regex~(`is`|`as`|walk_and_convert)%%),
        hide_group(group_by_regex("Clonning", mod, %regex~(clone)%%)),
        group_by_regex("Setup", mod, %regex~setup.*$%%)
    )
    document("Boost package for the AST", mod, "ast_boost.rst", groups)
}

def document_module_strings(_root : string) {
    var mod = find_module("strings")
    var groups <- array<DocGroup>(
        hide_group(group_by_regex("Internal builtin functions", mod, %regex~builtin%%)),
        group_by_regex("Character set", mod, %regex~(set_total|set_element|is_char_in_set)$%%),
        group_by_regex("Character groups", mod, %regex~is.+%%),
        group_by_regex("Character by index", mod, %regex~(character_at|character_uat|first_character)$%%),
        group_by_regex("String properties", mod, %regex~(empty|ends_with|length|starts_with)$%%),
        group_by_regex("String builder", mod, %regex~(build_string|format|write|write_char|write_chars|write_escape_string|build_hash)$%%),
        group_by_regex("das::string manipulation", mod, %regex~(append|resize|with_das_string)$%%),
        group_by_regex("String modifications", mod, %regex~(chop|escape|unescape|repeat|replace|reverse|slice|
strip|strip_left|strip_right|to_lower|to_lower_in_place|to_upper|to_upper_in_place|rtrim|safe_unescape|ltrim|trim)$%%),
        group_by_regex("Search substrings", mod, %regex~(find|rfind).*%%),
        group_by_regex("String comparison", mod, %regex~(compare_ignore_case)$%%),
        group_by_regex("String conversion routines", mod, %regex~(double|float|int|uint|int64|uint64|to_double|to_float|to_int|to_uint|to_int64|to_uint64|string|to_char|fmt|int8|to_int8|uint8|to_uint8|int16|to_int16|uint16|to_uint16|to_cpp_float)$%%),
        group_by_regex("String as array", mod, %regex~(modify_data|peek_data)$%%),
        group_by_regex("Low level memory allocation", mod, %regex~(delete_string|reserve_string_buffer)$%%)
    );
    document("String manipulation library", mod, "strings.rst", groups);
}

def document_module_strings_boost(_root : string) {
    var mod = find_module("strings_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Split and join", mod, %regex~(split|split_by_chars|join)$%%),
        group_by_regex("Formatting", mod, %regex~(wide|pad_left|pad_right|capitalize)$%%),
        group_by_regex("Queries and comparisons", mod, %regex~(is_character_at|eq|contains|count|is_null_or_whitespace)$%%),
        group_by_regex("Search and match", mod, %regex~(last_index_of|glob_match|text_match)$%%),
        group_by_regex("Replace", mod, %regex~(replace_multiple)$%%),
        group_by_regex("Prefix and suffix", mod, %regex~(trim_prefix|trim_suffix)$%%),
        group_by_regex("String similarity", mod, %regex~(levenshtein_distance|levenshtein_distance_fast|jaccard)$%%),
        group_by_regex("Character traits", mod, %regex~(is_hex|is_tab_or_space)$%%))
    document("Boost package for string manipulation library", mod, "strings_boost.rst", groups)
}

def document_module_strings_convert(_root : string) {
    var mod = find_module("strings_convert")
    var groups <- array<DocGroup>(
        group_by_regex("Soft-failing conversions", mod, %regex~try_to_(int|uint|int8|uint8|int16|uint16|int64|uint64|float|double)$%%))
    document("Soft-failing string-to-numeric conversions returning Result<T; ConversionError>", mod, "strings_convert.rst", groups)
}


def document_module_functional(_root : string) {
    var mod = find_module("functional")
    var groups <- array<DocGroup>(
        group_by_regex("Transformations", mod, %regex~(filter|map|flat_map|flatten|sorted|scan)$%%),
        group_by_regex("Aggregation", mod, %regex~(reduce|reduce_or_default|fold|sum|any|all|count)$%%),
        group_by_regex("Search and split", mod, %regex~(find|find_index|partition)$%%),
        group_by_regex("Iteration", mod, %regex~(for_each|tap|echo|enumerate|long_enumerate)$%%),
        group_by_regex("Generators", mod, %regex~(repeat_ref|repeat|cycle|iterate|chain|pairwise|islice)$%%),
        group_by_regex("Predicates", mod, %regex~(is_equal|is_not_equal|not)$%%)
    )
    document("Functional programming library", mod, "functional.rst", groups)
}

def document_module_json(_root : string) {
    var mod = find_module("json")
    var groups <- array<DocGroup>(
        group_by_regex("Value conversion", mod, %regex~(JV|JVNull)$%%),
        group_by_regex("Read and write", mod, %regex~(read_json|write_json|write_json_compact)$%%),
        group_by_regex("Memory management", mod, %regex~(delete_json|update|json_null_sentinel)$%%),
        group_by_regex("JSON properties", mod, %regex~(set_no_trailing_zeros|set_no_empty_arrays|set_allow_duplicate_keys)$%%),
        group_by_regex("Broken JSON", mod, %regex~(try_fixing_broken_json)$%%)
    )
    document("JSON manipulation library", mod, "json.rst", groups)
}

def document_module_json_boost(_root : string) {
    var mod = find_module("json_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Value conversion", mod, %regex~(JV|from_JV)$%%),
        group_by_regex("LINQ source builders", mod, %regex~(from_json|from_json_row|read_json_field)$%%),
        group_by_regex("Element access operators", mod, %regex~(\[\]|\?\[\]|\?\.|\.)$%%),
        group_by_regex("Null coalescing operators", mod, %regex~(\?\?)$%%),
        group_by_regex("Value extraction", mod, %regex~(\?\.)?`value$%%),
        group_by_regex("Annotation parsing", mod, %regex~(parse_json_annotation)$%%)
    )
    document("Boost package for JSON", mod, "json_boost.rst", groups)
}

def document_module_jsonrpc(_root : string) {
    var mod = find_module("jsonrpc")
    var groups <- array<DocGroup>(
        group_by_regex("Envelope builders", mod, %regex~(response|error|error_with_data|serialize_id)$%%),
        group_by_regex("Server-side parsers", mod, %regex~(parse_request|parse_batch)$%%),
        group_by_regex("Outgoing request builders", mod, %regex~(make_request|make_notification|make_batch)$%%),
        group_by_regex("Response parsers", mod, %regex~(parse_response|parse_response_batch)$%%),
        group_by_regex("Framing helper", mod, %regex~(compact_json_whitespace)$%%),
        group_by_regex("High-level dispatch", mod, %regex~(dispatch_line)$%%)
    )
    document("JSON-RPC 2.0 envelope + parser, transport-agnostic", mod, "jsonrpc.rst", groups)
}

def document_module_regex(_root : string) {
    var mod = find_module("regex")
    var groups <- array<DocGroup>(
        group_by_regex("Compilation and validation", mod, %regex~(regex_compile|is_valid|regex_debug|debug_set|visit_top_down)$%%),
        group_by_regex("Access", mod, %regex~(regex_group|regex_group_by_name|regex_foreach|\[\])$%%),
        group_by_regex("Match & replace", mod, %regex~(regex_match|regex_replace|regex_search|regex_split|regex_match_all)$%%),
        group_by_regex("Generation", mod, %regex~(re_gen.*)$%%)
    )
    document("Regular expression library", mod, "regex.rst", groups)
}

def document_module_regex_boost(_root : string) {
    var mod = find_module("regex_boost")
    var groups <- array<DocGroup>(
    )
    document("Boost package for REGEX", mod, "regex_boost.rst", groups)
}

def document_module_rst(_root : string) {
    var mod = find_module("rst")
    var groups <- array<DocGroup>(
        group_by_regex("Document writers", mod, %regex~document%%),
        group_by_regex("Descriptions", mod, %regex~describe%%),
        group_by_regex("Label makers", mod, %regex~(\w+_label_name|function_label_file)%%),
        group_by_regex("RST section makers", mod, %regex~make%%),
        group_by_regex("Documentation queries", mod, %regex~.+_needs%%),
        group_by_regex("Group operations", mod, %regex~.*group%%),
        group_by_regex("Naming helpers", mod, %regex~(topic|module_name|function_name|safe_function_name)$%%)
    )
    document("Documentation generator", mod, "rst.rst", groups)
}

def document_module_apply(_root : string) {
    var mod = find_module("apply")
    var groups <- array<DocGroup>(
    )
    document("Apply reflection pattern", mod, "apply.rst", groups)
}

def document_module_jobque(_root : string) {
    var mod = find_module("jobque")
    var groups <- array<DocGroup>(
        group_by_regex("Channel, JobStatus, Lockbox, Stream", mod, %regex~(append|notify|join|channel_create|channel_remove|stream_create|stream_remove|add_ref|release|notify_and_release|lock_box_create|lock_box_remove|job_status_create|job_status_remove)$%%),
        group_by_regex("Queries", mod, %regex~(get_total_hw_jobs|get_total_hw_threads|get_total_hw_cores|is_job_que_shutting_down|is_job_que_available|count_jobque_leaks)$%%),
        group_by_regex("Event tracing", mod, %regex~(jobque_trace_start|jobque_trace_stop|jobque_trace_save|jobque_trace_tag|jobque_trace_category|jobque_trace_marker_name|jobque_trace_marker)$%%),
        group_by_regex("Internal invocations", mod, %regex~(new_job_invoke|new_thread_invoke|new_debugger_thread|set_jobque_fork_pool|set_jobque_fork_skip_heap_reset|set_jobque_worker_spin|set_jobque_batch_dispatch|set_jobque_join_spin|set_jobque_team_mode|get_jobque_team_mode|set_jobque_thread_team_mode|get_jobque_thread_team_mode|set_current_thread_priority|set_jobque_threads_cap|set_jobque_affinity|get_jobque_affinity|set_jobque_worker_limit|get_jobque_worker_limit|set_jobque_team_rank_gate|get_jobque_team_rank_gate|set_jobque_team_prof|reset_jobque_team_prof|get_jobque_team_prof|get_jobque_team_prof_counts|get_jobque_team_prof_react|team_parallel_for_invoke|team_parallel_for_indexed_invoke|team_parallel_stages_invoke|flush_jobque_batch|jobque_try_run_one)$%%),
        group_by_regex("Construction", mod, %regex~(with_channel|with_stream|with_job_status|with_job_que|with_lock_box|create_job_que|destroy_job_que)$%%),
        group_by_regex("Atomic", mod, %regex~(atomic32_create|atomic32_remove|with_atomic32|atomic64_create|atomic64_remove|with_atomic64|get|set|inc|dec)$%%)
    )
    document("Jobs and threads", mod, "jobque.rst", groups)
}

def document_module_jobque_boost(_root : string) {
    var mod = find_module("jobque_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Invocations", mod, %regex~(new_job|new_thread)$%%),
        group_by_regex("Iteration", mod, %regex~(for_each|each|each_clone|for_each_clone)$%%),
        group_by_regex("Passing data", mod, %regex~(push|push_clone|push_batch|push_batch_clone|push_archive)$%%),
        group_by_regex("Receiving data", mod, %regex~(gather|gather_ex|gather_and_forward|peek|pop|pop_one|pop_and_clone_one|try_pop|try_pop_clone|pop_with_timeout|pop_with_timeout_clone|pop_archive|try_pop_archive|gather_archive)$%%),
        group_by_regex("Synchronization", mod, %regex~(with_wait_group|done)$%%),
        group_by_regex("Parallel execution", mod, %regex~(_parallel_for|parallel_for|team_parallel_for|team_parallel_for_indexed|team_parallel_stages|_parallel_for_each|parallel_for_each|_parallel_map|parallel_map)$%%),
        group_by_regex("LockBox operations", mod, %regex~(set|get|update|clear|fill|grab)$%%),
        group_by_regex("Internal capture details", mod, %regex~(capture_jobque_channel|capture_jobque_job_status|release_capture_jobque_channel|release_capture_jobque_job_status|capture_jobque_lock_box|release_capture_jobque_lock_box|capture_jobque_stream|release_capture_jobque_stream)$%%)
    )
    document("Boost package for jobs and threads", mod, "jobque_boost.rst", groups)
}

def document_module_jobque_profile(_root : string) {
    var mod = find_module("jobque_profile")
    var groups <- array<DocGroup>(
        group_by_regex("Trace sessions", mod, %regex~(profile_start|profile_stop|profile_save)$%%),
        group_by_regex("Categories", mod, %regex~(profile_category|profile_tag)$%%),
        group_by_regex("Markers", mod, %regex~(profile_marker|profile_marker_id)$%%)
    )
    document("Self-describing jobque profiling", mod, "jobque_profile.rst", groups)
}

def document_module_apply_in_context(_root : string) {
    var mod = find_module("apply_in_context")
    var groups <- array<DocGroup>(
    )
    document("Cross-context evaluation helpers", mod, "apply_in_context.rst", groups)
}

def document_module_ansi_colors(_root : string) {
    var mod = find_module("ansi_colors")
    var groups <- array<DocGroup>(
        group_by_regex("Configuration", mod, %regex~.*(init_ansi_colors|use_tty_colors)$%%),
        group_by_regex("Colors", mod, %regex~.*(red_str|green_str|yellow_str|blue_str|magenta_str|cyan_str)$%%),
        group_by_regex("Styles", mod, %regex~.*(bold_str|dim_str|underline_str|reset_str)$%%)
    )
    document("ANSI terminal color and style helpers", mod, "ansi_colors.rst", groups)
}

def document_module_tty(_root : string) {
    var mod = find_module("tty")
    var groups <- array<DocGroup>(
        group_by_regex("Terminal detection", mod, %regex~.*(is_stream_terminal|is_stdin_terminal|is_stdout_terminal|is_stderr_terminal)$%%),
        group_by_regex("Terminal geometry", mod, %regex~.*(terminal_columns)$%%)
    )
    document("Terminal capability probes", mod, "tty.rst", groups)
}

def document_module_algorithm(_root : string) {
    var mod = find_module("algorithm")
    var groups <- array<DocGroup>(
        group_by_regex("Search", mod, %regex~(lower_bound|upper_bound|binary_search|equal_range)$%%),
        group_by_regex("Array manipulation", mod, %regex~(unique|sort_unique|reverse|combine|erase_all|topological_sort|fill|is_sorted|rotate|min_element|max_element)$%%),
        group_by_regex("Table manipulation", mod, %regex~(intersection|union|difference|symmetric_difference|identical|is_subset)$%%)
    )
    document("Miscellaneous algorithms", mod, "algorithm.rst", groups)
}

def document_module_contracts(_root : string) {
    var mod = find_module("contracts")
    var groups <- array<DocGroup>(
        group_by_regex("Type queries", mod, %regex~(isYetAnotherVectorTemplate)$%%)
    )
    document("Miscellaneous contract annotations", mod, "contracts.rst", groups)
}

def document_module_delegate(_root : string) {
    var mod = find_module("delegate")
    var groups <- array<DocGroup>(
        group_by_regex("Delegate type macro", mod, %regex~(delegate)$%%)
    )
    document("C#-like multicast delegate type macro", mod, "delegate.rst", groups)
}

def document_module_option(_root : string) {
    var mod = find_module("option")
    var groups <- array<DocGroup>(
        group_by_regex("Constructors",  mod, %regex~(some|move_some|none)$%%),
        group_by_regex("Queries",       mod, %regex~(is_some|is_none)$%%),
        group_by_regex("Transforming",  mod, %regex~(map|and_then|filter|or_else|or_value)$%%),
        group_by_regex("Extraction",    mod, %regex~(unwrap|unwrap_or|unwrap_or_else|unwrap_or_default|expect_value|move_unwrap)$%%),
        group_by_regex("Side effects",  mod, %regex~(if_some|if_none)$%%),
        group_by_regex("Pairing",       mod, %regex~(zip)$%%),
        group_by_regex("Operators",     mod, %regex~(==|!=|\?\?)$%%)
    )
    document("Monadic Option<T> — a value-or-nothing tagged pair", mod, "option.rst", groups)
}

def document_module_result(_root : string) {
    var mod = find_module("result")
    var groups <- array<DocGroup>(
        group_by_regex("Constructors",  mod, %regex~(ok|err|move_ok|move_err)$%%),
        group_by_regex("Queries",       mod, %regex~(is_ok|is_err)$%%),
        group_by_regex("Transforming",  mod, %regex~(map|map_err|and_then|or_else)$%%),
        group_by_regex("Extraction",    mod, %regex~(unwrap|unwrap_or|unwrap_or_else|unwrap_or_default|unwrap_err|expect_value|expect_err|move_unwrap|move_unwrap_err)$%%),
        group_by_regex("Side effects",  mod, %regex~(if_ok|if_err)$%%),
        group_by_regex("Bridges to Option", mod, %regex~(to_option|err_to_option)$%%),
        group_by_regex("Operators",     mod, %regex~(==|!=|\?\?)$%%)
    )
    document("Monadic Result<T, E> — a value-or-error tagged pair", mod, "result.rst", groups)
}

def document_module_defer(_root : string) {
    var mod = find_module("defer")
    var groups <- array<DocGroup>(
        group_by_regex("Defer", mod, %regex~(defer)$%%),
        group_by_regex("Stub", mod, %regex~(nada)$%%)
    )
    document("defer and defer_delete macros", mod, "defer.rst", groups)
}

def document_module_with_boost(_root : string) {
    var mod = find_module("with_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Locked element binding helpers", mod, %regex~(_with_locked_.*)$%%)
    )
    document("``with_`` macro: locked array/table element binding", mod, "with_boost.rst", groups)
}

def document_module_if_not_null(_root : string) {
    var mod = find_module("if_not_null")
    var groups <- array<DocGroup>(
    )
    document("if_not_null macro", mod, "if_not_null.rst", groups)
}

def document_module_instance_function(_root : string) {
    var mod = find_module("instance_function")
    var groups <- array<DocGroup>(
    )
    document("instance_function function annotation", mod, "instance_function.rst", groups)
}

def document_module_templates(_root : string) {
    var mod = find_module("templates")
    var groups <- array<DocGroup>(
    )
    document("decltype macro and template function annotation", mod, "templates.rst", groups)
}

def document_module_templates_boost(_root : string) {
    var mod = find_module("templates_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Template rules", mod, %regex~(kaboomVarField|replaceVariable|renameVariable|replaceType|replaceAnnotationArgument|replaceBlockArgument|replaceVarTag|replaceArgumentWithList|replaceVariableWithList|renameField|replaceStructWithTypeDecl|replaceTypeWithTypeDecl|renameCall)$%%),
        group_by_regex("Template application", mod, %regex~(apply_template|clone_and_rename_var)$%%),
        group_by_regex("Expression helpers", mod, %regex~(remove_deref|visit_expression|expression_at)$%%),
        group_by_regex("Expression generation", mod, %regex~(make_expression_block)$%%),
        group_by_regex("Block helpers", mod, %regex~(unquote_block|move_unquote_block|push_block_list)$%%),
        group_by_regex("Global variable helpers", mod, %regex~(add_global_var|add_global_let|add_global_private_var|add_global_private_let)$%%),
        group_by_regex("Hygienic names", mod, %regex~(make_unique_private_name)$%%),
        group_by_regex("Quoting macros", mod, %regex~(apply_qmacro|apply_qblock|apply_qblock_to_array|apply_qblock_expr|apply_qtype|apply_qmacro_function|apply_qmacro_method|apply_qmacro_variable|apply_qmacro_template_class|apply_qmacro_template_function)$%%),
        group_by_regex("Type pointer helpers", mod, %regex~(add_type_ptr_ref|add_array_ptr_ref)$%%),
        group_by_regex("Structure helpers", mod, %regex~(add_structure_field)$%%),
        group_by_regex("Class generation", mod, %regex~(make_class|make_class_constructor|modify_to_class_member|enum_class_type)$%%)
    )
    document("Template application helpers", mod, "templates_boost.rst", groups)
}

def document_module_is_local(_root : string) {
    var mod = find_module("is_local")
    var groups <- array<DocGroup>(
        group_by_regex("Scope checks", mod, %regex~(is_local_expr|is_local_or_global_expr|is_scope_expr|is_temp_safe|is_shared_expr)$%%)
    )
    document("is_local_xxx ast helpers", mod, "is_local.rst", groups)
}

def document_module_safe_addr(_root : string) {
    var mod = find_module("safe_addr")
    var groups <- array<DocGroup>(
        group_by_regex("Safe temporary address", mod, %regex~(safe_addr|shared_addr)$%%),
        group_by_regex("Temporary pointers", mod, %regex~(temp_ptr)$%%),
        group_by_regex("Temporary values", mod, %regex~(temp_value)$%%)
    )
    document("safe_addr macro", mod, "safe_addr.rst", groups)
}

def document_module_static_let(_root : string) {
    var mod = find_module("static_let")
    var groups <- array<DocGroup>(
        group_by_regex("Static variable declarations", mod, %regex~(static_let|static_let_finalize)$%%)
    )
    document("static_let macro", mod, "static_let.rst", groups)
}

def document_module_lpipe(_root : string) {
    var mod = find_module("lpipe")
    var groups <- array<DocGroup>(
    )
    document("lpipe macro", mod, "lpipe.rst", groups)
}

def document_module_math_bits(_root : string) {
    var mod = find_module("math_bits")
    var groups <- array<DocGroup>(
        group_by_regex("float in int,uint", mod, %regex~(int_bits_to_float|uint_bits_to_float)$%%),
        group_by_regex("int,uint in float", mod, %regex~(float_bits_to_int|float_bits_to_uint)$%%),
        group_by_regex("int64,uint64 in double", mod, %regex~(int64_bits_to_double|uint64_bits_to_double|double_bits_to_int64|double_bits_to_uint64)$%%),
        group_by_regex("bit-cast vec4f", mod, %regex~(cast_to.*)$%%))
    document("Math bit helpers", mod, "math_bits.rst", groups)
}

def document_module_math_boost(_root : string) {
    var mod = find_module("math_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Angle conversions", mod, %regex~(degrees|radians)$%%),
        group_by_regex("Intersections", mod, %regex~(is_intersecting)$%%),
        group_by_regex("Matrices", mod, %regex~(look_at_lh|look_at_rh|perspective_lh|perspective_rh|perspective_rh_opengl|perspective_rh_0_to_1|perspective_rh_minus1_to_1|ortho_rh|planar_shadow)$%%),
        group_by_regex("Plane", mod, %regex~(plane_dot|plane_normalize|plane_from_point_normal)$%%),
        group_by_regex("Color conversions", mod, %regex~(linear_to_SRGB)$%%),
        group_by_regex("Color packing and unpacking", mod, %regex~(RGBA_TO_UCOLOR|UCOLOR_TO_RGBA|UCOLOR_TO_RGB)$%%)
    )
    document("Boost package for math", mod, "math_boost.rst", groups)
}

def document_module_md_boost(_root : string) {
    var mod = find_module("md_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Tables", mod, %regex~(render_md_table|ColAlign)$%%),
        group_by_regex("Text helpers", mod, %regex~(md_bold|md_escape)$%%)
    )
    document("Markdown generation helpers", mod, "md_boost.rst", groups)
}

def document_module_array_boost(_root : string) {
    var mod = find_module("array_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Temporary arrays", mod, %regex~(temp_array)$%%),
        group_by_regex("Empty check", mod, %regex~(empty)$%%),
        group_by_regex("Sub-array view", mod, %regex~(array_view|pod_view)$%%)
    )
    document("Boost package for array manipulation", mod, "array_boost.rst", groups)
}

def document_module_archive(_root : string) {
    var mod = find_module("archive")
    var groups <- array<DocGroup>(
        group_by_regex("Serialization", mod, %regex~(serialize|serialize_raw|read_raw|write_raw)$%%),
        group_by_regex("Memory archive", mod, %regex~(mem_archive_save|mem_archive_load)$%%)
    )
    document("General purpose serialization", mod, "archive.rst", groups)
}

def document_module_unroll(_root : string) {
    var mod = find_module("unroll")
    var groups <- array<DocGroup>(
        group_by_regex("Unrolling", mod, %regex~(unroll)$%%)
    )
    document("Loop unrolling", mod, "unroll.rst", groups)
}

def document_module_assert_once(_root : string) {
    var mod = find_module("assert_once")
    var groups <- array<DocGroup>(
        group_by_regex("Assertion", mod, %regex~(assert_once)$%%)
    )
    document("Assert once", mod, "assert_once.rst", groups)
}

def document_module_ast_block_to_loop(_root : string) {
    var mod = find_module("ast_block_to_loop")
    var groups <- array<DocGroup>(
        group_by_regex("Block to loop conversion", mod, %regex~(convert_block_to_loop)$%%)
    )
    document("DECS, AST block to loop", mod, "ast_block_to_loop.rst", groups)
}

def document_module_ast_cursor(_root : string) {
    var mod = find_module("ast_cursor")
    var groups <- array<DocGroup>(
        group_by_regex("Cursor queries", mod, %regex~.*(find_at_cursor|find_at_cursor_in_function|cursor_inside)$%%),
        group_by_regex("Result inspection", mod, %regex~.*(describe)$%%)
    )
    document("Position-based AST queries", mod, "ast_cursor.rst", groups)
}

def document_module_ast_used(_root : string) {
    var mod = find_module("ast_used")
    var groups <- array<DocGroup>(
        group_by_regex("Collecting type information", mod, %regex~(collect_used_types)$%%)
    )
    document("AST type usage collection", mod, "ast_used.rst", groups)
}

def document_module_ast_match(_root : string) {
    var mod = find_module("ast_match")
    var groups <- array<DocGroup>(
        group_by_regex("Match execution", mod, %regex~.*(qm_run|qm_run_function)$%%),
        group_by_regex("Call matching", mod, %regex~.*(match_call_in_module|match_call_in_linq)$%%),
        group_by_regex("Result builders", mod, %regex~.*(qm_ok|qm_fail_.*)$%%),
        group_by_regex("Value extraction", mod, %regex~.*(qm_extract|extract_const_string)$%%),
        group_by_regex("Name and type extraction", mod, %regex~.*(qm_extract_name|qm_extract_call_name|qm_extract_field_name|qm_extract_type|qm_rtti|qm_call_name_matches)$%%),
        group_by_regex("Argument filtering", mod, %regex~.*(qm_count_real_args|qm_real_arg_index|qm_extract_remaining_args|qm_is_fake_arg|qm_count_real_call_args|qm_real_call_arg_index)$%%),
        group_by_regex("Block scanning", mod, %regex~.*(qm_scan|qm_extract_stmts)$%%),
        group_by_regex("Constant construction", mod, %regex~.*(qm_make_zero_const)$%%),
        group_by_regex("AST reconstruction", mod, %regex~.*(qm_convert_local_function|qm_resolve_local_function|qm_convert_comprehension|qm_resolve_comprehension)$%%),
        group_by_regex("AST normalization", mod, %regex~.*(qm_peel_ref2value|peel_lambda.*|peel_tuple_field_read)$%%),
        group_by_regex("Hygienic names", mod, %regex~.*(qn)$%%)
    )
    document("AST pattern matching", mod, "ast_match.rst", groups)
}

def document_module_constexpr(_root : string) {
    var mod = find_module("constant_expression")
    var groups <- array<DocGroup>(
        group_by_regex("Macro helpers", mod, %regex~(isConstantExpression)$%%)
    )
    document("Constant expression checker and substitution", mod, "constexpr.rst", groups)
}

def document_module_uriparser_boost(_root : string) {
    var mod = find_module("uriparser_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Split and compose", mod, %regex~(uri_split_full_path|uri_compose_query|uri_compose_query_in_order|uri_compose)$%%),
        group_by_regex("Component accessors", mod, %regex~(scheme|user_info|host|port|path|query|fragment)$%%)
    )
    document("Boost package for the URI parser", mod, "uriparser_boost.rst", groups)
}

def document_module_pugixml(_root : string) {
    // NOTE: regex_match is start-anchored, so patterns must begin with .* to match
    // property names like .`ok, .`first_child (dot-backtick prefix).
    var mod = get_module("pugixml")
    var groups <- array<DocGroup>(
        group_by_regex("Document operations", mod, %regex~.*(document_element|document_as_node|load_document|load_string|save_file|save_string|reset)$%%),
        group_by_regex("Node lookup", mod, %regex~.*(child|find_child_by_attribute|first_element_by_path)$%%),
        group_by_regex("Node navigation", mod, %regex~.*(first_child|last_child|next_sibling|previous_sibling|parent|root|path|print_to_string)$%%),
        group_by_regex("Node mutation", mod, %regex~.*(set_name|set_value|append_child|prepend_child|insert_child_after|insert_child_before|remove_child|remove_children)$%%),
        group_by_regex("Attribute access", mod, %regex~.*(attribute|first_attribute|last_attribute|next_attribute|previous_attribute|append_attribute|prepend_attribute|insert_attribute_after|insert_attribute_before|remove_attribute|remove_attributes)$%%),
        group_by_regex("Copy and move", mod, %regex~.*(append_copy|prepend_copy|append_move|prepend_move)$%%),
        group_by_regex("Value reading", mod, %regex~.*(as_string|as_int|as_uint|as_float|as_double|as_bool|as_int64|as_uint64|text|data|child_value)$%%),
        group_by_regex("Value writing", mod, %regex~.*^set$%%),
        group_by_regex("XPath compilation and evaluation", mod, %regex~.*(xpath_compile|evaluate_boolean|evaluate_number|evaluate_string|evaluate_node_set|evaluate_node|return_type|result_description|result_offset)$%%),
        group_by_regex("XPath selection", mod, %regex~.*(select_node|select_nodes|node)$%%),
        group_by_regex("XPath node set operations", mod, %regex~.*(at|sort|size|empty|first)$%%),
        group_by_regex("Construction and RAII", mod, %regex~.*(xml_document|xpath_node_set|xpath_variable_set|using)$%%),
        group_by_regex("Handle validity and comparison", mod, %regex~.*(ok|hash_value|offset_debug|==|!=)$%%)
    )
    document("XML parser (pugixml)", mod, "pugixml.rst", groups)
}

def document_module_PUGIXML_boost(_root : string) {
    // NOTE: regex_match is start-anchored. Backtick operator names like `is`int
    // need regex_compile (reader macro %regex~ can't embed literal backticks).
    var mod = find_module("PUGIXML_boost")
    var r_type_conv : Regex
    regex_compile(r_type_conv, ".*(`is`|`as`|\\[\\])")
    var groups <- array<DocGroup>(
        group_by_regex("Block-based iteration", mod, %regex~.*(for_each_child_reverse|for_each_child|for_each_attribute|for_each)$%%),
        group_by_regex("Iterator-based iteration", mod, %regex~.*(each_child_reverse|each|each_child|each_attribute)$%%),
        group_by_regex("LINQ source", mod, %regex~.*(from_xml_node|build_xml_row|read_xml_field|peek_xml_field)$%%),
        group_by_regex("RAII document handling", mod, %regex~.*(open_xml|parse_xml|with_doc)$%%),
        group_by_regex("Quick accessors", mod, %regex~.*(node_text|node_attr|node_attr_int|node_attr_float|node_attr_bool)$%%),
        group_by_regex("Builder helpers", mod, %regex~.*(add_child|add_child_ex|add_attr)$%%),
        group_by_regex("Builder EDSL", mod, %regex~.*(tag|attr)$%%),
        group_by_regex("String conversion", mod, %regex~.*(to_string)$%%),
        group_by_regex("XPath helpers", mod, %regex~.*(with_xpath|select_text|select_value|for_each_select)$%%),
        group_by_regex("Serialization", mod, %regex~.*(to_XML|from_XML|XML|XML_table)$%%),
        group_by_regex("Type conversion operators", mod, r_type_conv)
    )
    document("High-level XML helpers (pugixml boost)", mod, "PUGIXML_boost.rst", groups)
}

def document_module_sort_boost(_root : string) {
    var mod = find_module("sort_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Partial sorting", mod, %regex~(partial_sort|nth_element|qpartial_sort|qnth_element)$%%),
        group_by_regex("Heap operations", mod, %regex~(make_heap|push_heap|pop_heap|qmake_heap|qpush_heap|qpop_heap)$%%),
        group_by_regex("Sort dispatch macro", mod, %regex~qsort$%%)
    )
    document("Boost package for the builtin sort", mod, "sort_boost.rst", groups)
}

def document_module_enum_trait(_root : string) {
    var mod = find_module("enum_trait")
    var groups <- array<DocGroup>(
        group_by_regex("Enumeration iteration", mod, %regex~(each|each_name|find_value)$%%),
        group_by_regex("Enumeration conversion", mod, %regex~(string|to_enum|enum_to_table|bool|\!)$%%)
    )
    document("Enumeration traits", mod, "enum_trait.rst", groups)
}

def document_module_cpp_bind(_root : string) {
    var mod = find_module("cpp_bind")
    var groups <- array<DocGroup>(
        group_by_regex("Generation of bindings", mod, %regex~(log_cpp_class_adapter)$%%)
    )
    document("C++ bindings generator", mod, "cpp_bind.rst", groups)
}

def document_module_decs(_root : string) {
    var mod = find_module("decs")
    var groups <- array<DocGroup>(
        group_by_regex("Comparison and access", mod, %regex~(\=\=|\!\=|\.)$%%),
        group_by_regex("Access (get/set/clone)", mod, %regex~(has|get|set|set_direct|set_direct_at|clone|remove|get_component|find_component_index)$%%),
        group_by_regex("Entity status", mod, %regex~(is_alive|entity_count|long_entity_count)$%%),
        group_by_regex("Debug and serialization", mod, %regex~(describe|serialize|finalize|debug_dump.*)$%%),
        group_by_regex("Stages", mod, %regex~(register_decs_stage_call|decs_stage|commit)$%%),
        group_by_regex("Deferred actions", mod, %regex~(update_entity|create_entity|create_entities|create_entities_from_cmp|delete_entity)$%%),
        group_by_regex("GC and reset", mod, %regex~(before_gc|after_gc|restart)$%%),
        group_by_regex("Iteration", mod, %regex~(for_each_archetype|for_eid_archetype|for_each_archetype_find|get_ro|decs_array|get_default_ro|get_optional)$%%),
        group_by_regex("Request", mod, %regex~(verify_request|compile_request|lookup_request|EcsRequestPos)$%%)
    )
    document("DECS, Daslang entity component system", mod, "decs.rst", groups)
}

def document_module_decs_boost(_root : string) {
    var mod = find_module("decs_boost")
    var groups <- array<DocGroup>(
    )
    document("Boost package for DECS", mod, "decs_boost.rst", groups)
}

def document_module_utf8_utils(_root : string) {
    var mod = find_module("utf8_utils")
    var groups <- array<DocGroup>(
        group_by_regex("Encoding and decoding", mod, %regex~(utf8_encode|utf8_decode|utf16_to_utf32|utf32_to_utf16|decode_unicode_escape)$%%),
        group_by_regex("Iteration", mod, %regex~(each_utf32|each_word)$%%),
        group_by_regex("Length and measurement", mod, %regex~(utf8_length)$%%),
        group_by_regex("Validation", mod, %regex~(is_first_byte_of_utf8_char|contains_utf8_bom|is_utf8_string_valid)$%%),
        group_by_regex("Unicode word/case primitives", mod, %regex~(utf32_is_word_char|utf32_to_lower)$%%)
    )
    document("UTF-8 utilities", mod, "utf8_utils.rst", groups)
}

def document_module_macro_boost(_root : string) {
    var mod = find_module("macro_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Implementation details", mod, %regex~(macro_verify)$%%),
        group_by_regex("Block analysis", mod, %regex~(capture_block|collect_finally|collect_labels)$%%),
        group_by_regex("Expression analysis", mod, %regex~(has_sideeffects)$%%)
    )
    document("Boost package for macro manipulations", mod, "macro_boost.rst", groups)
}

def document_module_coroutines(_root : string) {
    var mod = find_module("coroutines")
    var groups <- array<DocGroup>(
        group_by_regex("Top level coroutine evaluation", mod, %regex~(cr_run|cr_run_all)$%%)
    )
    document("Coroutines and additional generator support", mod, "coroutines.rst", groups)
}

def document_module_interfaces(_root : string) {
    var mod = find_module("interfaces")
    var groups <- array<DocGroup>(
    )
    document("Interfaces", mod, "interfaces.rst", groups)
}

def document_module_faker(_root : string) {
    var mod = find_module("faker")
    var groups <- array<DocGroup>(
        group_by_regex("Constructor", mod, %regex~(Faker)$%%),
        group_by_regex("Random values", mod, %regex~random_.*$%%),
        group_by_regex("Random strings", mod, %regex~(any_.*|long_string|number|positive_int)$%%),
        group_by_regex("Date and time", mod, %regex~(month|day|date|is_leap_year|week_day)%%)
    )
    document("Faker", mod, "faker.rst", groups)
}

def document_module_flat_hash_table(_root : string) {
    var mod = find_module("flat_hash_table")
    var groups <- array<DocGroup>(
        group_by_regex("Template structure", mod, %regex~(TFlatHashTable)$%%),
        group_by_regex("Basic operations", mod, %regex~(empty|length|clear|key_exists|erase|get)$%%),
        group_by_regex("Memory management", mod, %regex~(grow|rehash|reserve)$%%),
        group_by_regex("Iteration", mod, %regex~(foreach|keys|values)$%%),
        group_by_regex("Internal operations", mod, %regex~(key_index)$%%),
        group_by_regex("Operators", mod, %regex~(\[\]|\?\[\])$%%)
    )
    document("Flat hash table", mod, "flat_hash_table.rst", groups)
}

def document_module_fuzzer(_root : string) {
    var mod = find_module("fuzzer")
    var groups <- array<DocGroup>(
        group_by_regex("Fuzzer tests", mod, %regex~fuzz.*$%%)
    )
    document("Fuzzer", mod, "fuzzer.rst", groups)
}

def document_module_match(_root : string) {
    var mod = find_module("match")
    var groups <- array<DocGroup>(
        hide_group(group_by_regex("Implementation details", mod, %regex~(match_type|match_expr|match_peel_r2v)$%%))
    )
    document("Pattern matching", mod, "match.rst", groups)
}

def document_module_linq(_root : string) {
    var mod = find_module("linq")
    var groups <- array<DocGroup>(
        group_by_regex("Sorting data", mod, %regex~(reverse.*|order.*)$%%),
        group_by_regex("Top-N selection", mod, %regex~(top_n.*|spliced_push_heap|spliced_pop_heap)$%%),
        group_by_regex("Set operations", mod, %regex~(distinct.*|union.*|intersect.*|except.*|unique.*)$%%),
        group_by_regex("Concatenation operations", mod, %regex~(concat.*|append.*|prepend.*)$%%),
        group_by_regex("Generation operations", mod, %regex~(default_empty|repeat|empty|range_sequence)$%%),
        group_by_regex("Aggregation operations", mod, %regex~(count.*|long_count.*|sum.*|min.*|max.*|average.*|aggregate.*)$%%),
        group_by_regex("Filtering data", mod, %regex~(where_.*)$%%),
        group_by_regex("Partitioning data", mod, %regex~(skip.*|take.*|chunk.*)$%%),
        group_by_regex("Joining", mod, %regex~(join.*|left_join.*|right_join.*|full_outer_join.*|cross_join.*|group_join.*)$%%),
        group_by_regex("Grouping", mod, %regex~(group_by.*|having.*)$%%),
        group_by_regex("Querying data", mod, %regex~(all.*|any.*|contains.*|none.*)$%%),
        group_by_regex("Element operations", mod, %regex~(first.*|last.*|single.*|element_at.*)$%%),
        group_by_regex("Transform operations", mod, %regex~(select.*|zip.*)$%%),
        group_by_regex("Conversion operations", mod, %regex~(to_table.*|to_sequence.*)$%%),
        group_by_regex("Comparators and keys", mod, %regex~(less.*|unique_key.*|sequence_equal.*)$%%)
    )
    document("LINQ", mod, "linq.rst", groups)
}

def document_module_linq_boost(_root : string) {
    var mod = find_module("linq_boost")
    var groups <- array<DocGroup>(
        hide_group(group_by_regex("Implementation details", mod, %regex~(match_type|match_expr|match_peel_r2v)$%%))
    )
    document("Boost module for LINQ", mod, "linq_boost.rst", groups)
}

def document_module_linq_fold(_root : string) {
    var mod = find_module("linq_fold")
    var groups <- array<DocGroup>(
        group_by_regex("Pattern slot construction", mod, %regex~(m_literal|m_alias|c_one|c_opt|c_chain|slot_chain_of)$%%),
        group_by_regex("Pattern table validation", mod, %regex~(chain_prefix_of|check_pattern_table_reachable)$%%)
    )
    document("LINQ fold macros (_fold / _old_fold)", mod, "linq_fold.rst", groups)
}

def document_module_command_line(_root : string) {
    var mod = find_module("command_line")
    var groups <- array<DocGroup>(
        group_by_regex("Executable path", mod, %regex~(get_das_exe)$%%)
    )
    document("Command-line utilities", mod, "command_line.rst", groups)
}

def document_module_class_boost(_root : string) {
    var mod = find_module("class_boost")
    var groups <- array<DocGroup>(
    )
    document("Class method macros", mod, "class_boost.rst", groups)
}

def document_module_soa(_root : string) {
    var mod = find_module("soa")
    var groups <- array<DocGroup>(
        group_by_regex("SOA field access", mod, %regex~\.$%%)
    )
    document("SOA (Structure of Arrays) transformation", mod, "soa.rst", groups)
}

def document_module_base64(_root : string) {
    var mod = find_module("base64")
    var groups <- array<DocGroup>(
        group_by_regex("Encoding", mod, %regex~(base64_encode|BASE64_ENCODE_OUT_SIZE)$%%),
        group_by_regex("Decoding", mod, %regex~(base64_decode|BASE64_DECODE_OUT_SIZE)$%%)
    )
    document("Base64 encoding and decoding", mod, "base64.rst", groups)
}

// def document_module_linked_list(_root : string) {
//     var mod = find_module("linked_list")
//     var groups <- array<DocGroup>(
//     )
//     document("Intrusive linked list", mod, "linked_list.rst", groups)
// }

def document_module_bool_array(_root : string) {
    var mod = find_module("bool_array")
    var groups <- array<DocGroup>(
        group_by_regex("Iteration", mod, %regex~(each)$%%)
    )
    document("Packed boolean array", mod, "bool_array.rst", groups)
}

def document_module_bitfield_boost(_root : string) {
    var mod = find_module("bitfield_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Bitfield element access", mod, %regex~(\[\]|\[\]\=|\[\]\&\&\=|\[\]\|\|\=|\[\]\^\^\=)$%%),
        group_by_regex("Iteration", mod, %regex~(each_bit)$%%)
    )
    document("Bitfield operator overloads", mod, "bitfield_boost.rst", groups)
}

def document_module_bitfield_trait(_root : string) {
    var mod = find_module("bitfield_trait")
    var groups <- array<DocGroup>(
        group_by_regex("Iteration", mod, %regex~(each|each_bit_name)$%%)
    )
    document("Bitfield name traits", mod, "bitfield_trait.rst", groups)
}

def document_module_async_boost(_root : string) {
    var mod = find_module("async_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Awaiting", mod, %regex~(await|await_next_frame)$%%),
        group_by_regex("Running async tasks", mod, %regex~(async_run|async_run_all|async_timeout|async_race)$%%)
    )
    document("Async/await coroutine macros", mod, "async_boost.rst", groups)
}

def document_module_cuckoo_hash_table(_root : string) {
    var mod = find_module("cuckoo_hash_table")
    var groups <- array<DocGroup>(
        group_by_regex("Hash functions", mod, %regex~(hash0|hash1|hash_extra)$%%)
    )
    document("Cuckoo hash table", mod, "cuckoo_hash_table.rst", groups)
}

def document_module_consume(_root : string) {
    var mod = find_module("consume")
    var groups <- array<DocGroup>(
    )
    document("Consume argument optimization", mod, "consume.rst", groups)
}

def document_module_dap(_root : string) {
    var mod = find_module("dap")
    var groups <- array<DocGroup>(
        group_by_regex("JSON deserialization", mod, %regex~(InitializeRequestArguments|DisconnectArguments|DataBreakpoint|SetDataBreakpointsArguments|DataBreakpointInfoArguments|SourceBreakpoint|Source|SetBreakpointsArguments|StackTraceArguments|ScopesArguments|VariablesArguments|ContinueArguments|PauseArguments|StepInArguments|NextArguments|StepOutArguments|EvaluateArguments)$%%),
        group_by_regex("JSON serialization", mod, %regex~(JV)$%%),
        group_by_regex("JSON field accessors", mod, %regex~(joj|jon|j_s|jos|job)$%%)
    )
    document("Debug Adapter Protocol data structures", mod, "dap.rst", groups)
}

def document_module_das_source_formatter(_root : string) {
    var mod = find_module("das_source_formatter")
    var groups <- array<DocGroup>(
        group_by_regex("Formatting", mod, %regex~(format_das_string|format_source_string|format_source)$%%)
    )
    document("Source code formatter", mod, "das_source_formatter.rst", groups)
}

def document_module_das_source_formatter_fio(_root : string) {
    var mod = find_module("das_source_formatter_fio")
    var groups <- array<DocGroup>(
        group_by_regex("File formatting", mod, %regex~(format_file|format_files)$%%)
    )
    document("File-based source code formatter", mod, "das_source_formatter_fio.rst", groups)
}

def document_module_debug(_root : string) {
    var mod = find_module("debug")
    var groups <- array<DocGroup>(
    )
    document("DAP debug server", mod, "debug.rst", groups)
}

def document_module_debug_eval(_root : string) {
    var mod = find_module("debug_eval")
    var groups <- array<DocGroup>(
        group_by_regex("Evaluation", mod, %regex~(eval|debug_eval)$%%),
        group_by_regex("Tokenization", mod, %regex~(each_token)$%%)
    )
    document("Debug expression evaluator", mod, "debug_eval.rst", groups)
}

def document_module_decs_state(_root : string) {
    var mod = find_module("decs_state")
    var groups <- array<DocGroup>(
    )
    document("DECS debug state reporting", mod, "decs_state.rst", groups)
}

def document_module_dynamic_cast_rtti(_root : string) {
    var mod = find_module("dynamic_cast_rtti")
    var groups <- array<DocGroup>(
        group_by_regex("Dynamic casts", mod, %regex~(is_instance_of|as_instance_of|dynamic_type_cast|force_dynamic_type_cast)$%%)
    )
    document("Dynamic RTTI type casts", mod, "dynamic_cast_rtti.rst", groups)
}

def document_module_generic_return(_root : string) {
    var mod = find_module("generic_return")
    var groups <- array<DocGroup>(
    )
    document("Generic return type instantiation", mod, "generic_return.rst", groups)
}

def document_module_heartbeat(_root : string) {
    var mod = find_module("heartbeat")
    var groups <- array<DocGroup>(
        group_by_regex("Heartbeat control", mod, %regex~(set_heartbeat|heartbeat)$%%)
    )
    document("Heartbeat callback injection", mod, "heartbeat.rst", groups)
}

def document_module_lint(_root : string) {
    var mod = find_module("lint")
    var groups <- array<DocGroup>(
        group_by_regex("Lint operations", mod, %regex~(paranoid|paranoid_collect|paranoid_collect_issues)$%%)
    )
    document("Paranoid lint pass", mod, "lint.rst", groups)
}

def document_module_lint_config(_root : string) {
    var mod = find_module("lint_config")
    var groups <- array<DocGroup>(
        group_by_regex("Configuration", mod, %regex~(load_lint_config|load_lint_config_from_path|load_env_disabled|seed_default_disabled|build_lint_macro_disabled)$%%),
        group_by_regex("Structured findings", mod, %regex~(make_lint_issue)$%%)
    )
    document("Repo-level lint configuration", mod, "lint_config.rst", groups)
}

def document_module_toml(_root : string) {
    var mod = find_module("toml")
    var groups <- array<DocGroup>(
        group_by_regex("Parsing", mod, %regex~(read_toml)$%%),
        group_by_regex("Writing", mod, %regex~(write_toml)$%%)
    )
    document("TOML 1.0 parser and writer", mod, "toml.rst", groups)
}

def document_module_logger(_root : string) {
    var mod = find_module("logger")
    var groups <- array<DocGroup>(
        group_by_regex("Setup", mod, %regex~.*(logger_init|logger_init_tee|logger_set_name|logger_set_path|logger_get_path|logger_get_name)$%%),
        group_by_regex("Level filters", mod, %regex~.*(logger_set_min_level|logger_get_min_level|logger_set_category_level|logger_clear_category_levels)$%%),
        group_by_regex("Output control", mod, %regex~.*(logger_set_stderr_fallback|logger_set_tee|logger_flush|logger_close)$%%),
        group_by_regex("Log calls", mod, %regex~.*(logger_log|logger_trace|logger_debug|logger_info|logger_warning|logger_error|logger_critical)$%%),
        group_by_regex("Stdout hook", mod, %regex~.*(logger_install_hook)$%%)
    )
    document("Structured JSON Lines logger", mod, "logger.rst", groups)
}

def document_module_lint_everything(_root : string) {
    var mod = find_module("lint_everything")
    var groups <- array<DocGroup>(
    )
    document("Global paranoid lint pass", mod, "lint_everything.rst", groups)
}

def document_module_live(_root : string) {
    var mod = find_module("live")
    var groups <- array<DocGroup>(
        group_by_regex("Lifecycle", mod, %regex~(live_init|live_update|live_bind_server|live_main)$%%)
    )
    document("Live reload framework", mod, "live.rst", groups)
}

def document_module_profiler(_root : string) {
    var mod = find_module("profiler")
    var groups <- array<DocGroup>(
        group_by_regex("Profiler control", mod, %regex~(set_enable_profiler|set_enable_profiler_log)$%%)
    )
    document("Instrumenting profiler", mod, "profiler.rst", groups)
}

def document_module_profiler_boost(_root : string) {
    var mod = find_module("profiler_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Context profiler control", mod, %regex~(enable_profiler|disable_profiler|enable_profiler_log|disable_profiler_log)$%%)
    )
    document("Profiler cross-context helpers", mod, "profiler_boost.rst", groups)
}

def document_module_coverage(_root : string) {
    var mod = find_module("coverage")
    var groups <- array<DocGroup>(
        group_by_regex("Coverage data access", mod, %regex~(get_report|add_coverage)$%%)
    )
    document("Code coverage instrumentation", mod, "coverage.rst", groups)
}

def document_module_quote(_root : string) {
    var mod = find_module("quote")
    var groups <- array<DocGroup>(
        group_by_regex("Clone operations", mod, %regex~(clone|clone_line_info|clone_file_info|resolve_file_info)$%%),
        group_by_regex("Conversion", mod, %regex~(cvt_to_mks|make_alias_type_decl)$%%)
    )
    document("AST quasiquoting infrastructure", mod, "quote.rst", groups)
}

def document_module_refactor(_root : string) {
    var mod = find_module("refactor")
    var groups <- array<DocGroup>(
        group_by_regex("Refactoring operations", mod, %regex~(extract_method|rename|extract_expression|extract_variable_nonref|extract_variable_ref)$%%)
    )
    document("Automated refactoring tools", mod, "refactor.rst", groups)
}

def document_module_remove_call_args(_root : string) {
    var mod = find_module("remove_call_args")
    var groups <- array<DocGroup>(
    )
    document("Call argument removal annotation", mod, "remove_call_args.rst", groups)
}

def document_module_stringify(_root : string) {
    var mod = find_module("stringify")
    var groups <- array<DocGroup>(
    )
    document("Long string embedding macro", mod, "stringify.rst", groups)
}

def document_module_temp_strings(_root : string) {
    var mod = find_module("temp_strings")
    var groups <- array<DocGroup>(
        group_by_regex("Temporary string builders", mod, %regex~(build_temp_string)$%%),
        group_by_regex("Temporary string conversion", mod, %regex~(temp_string)$%%)
    )
    document("Temporary string utilities", mod, "temp_strings.rst", groups)
}

def document_module_type_traits(_root : string) {
    var mod = find_module("type_traits")
    var groups <- array<DocGroup>(
    )
    document("Type trait macros", mod, "type_traits.rst", groups)
}

def document_module_typemacro_boost(_root : string) {
    var mod = find_module("typemacro_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Enum helpers", mod, %regex~(int64_to_enum)$%%),
        group_by_regex("Template structure instantiation", mod, %regex~(make_typemacro_template_instance|is_typemacro_template_instance|template_structure_name)$%%),
        group_by_regex("Type inference helpers", mod, %regex~(infer_struct_aliases|infer_template_types|add_structure_aliases|verify_arguments)$%%),
        group_by_regex("String constant access", mod, %regex~(get_string_const)$%%),
        group_by_regex("Work tracking", mod, %regex~(is_custom_work_done|mark_custom_work_done)$%%),
        group_by_regex("Type macro arguments", mod, %regex~(typemacro_argument)$%%)
    )
    document("Type macro and template structure support", mod, "typemacro_boost.rst", groups)
}

def document_module_validate_code(_root : string) {
    var mod = find_module("validate_code")
    var groups <- array<DocGroup>(
    )
    document("Code validation annotations", mod, "validate_code.rst", groups)
}

def document_module_stbimage(_root : string) {
    var mod = get_module("stbimage")
    var groups <- array<DocGroup>(
        group_by_regex("Image loading", mod, %regex~(stbi_load|stbi_loadf|stbi_load_16|stbi_load_from_memory|stbi_loadf_from_memory|stbi_load_16_from_memory|stbi_load_gif_from_memory)$%%),
        group_by_regex("Image info", mod, %regex~(stbi_info|stbi_info_from_memory|stbi_is_hdr|stbi_is_hdr_from_memory|stbi_is_16_bit|stbi_is_16_bit_from_memory)$%%),
        group_by_regex("Memory management", mod, %regex~(stbi_image_free|stbi_failure_reason)$%%),
        group_by_regex("Load settings", mod, %regex~(stbi_set_flip_vertically_on_load|stbi_set_unpremultiply_on_load|stbi_convert_iphone_png_to_rgb)$%%),
        group_by_regex("HDR gamma and scale", mod, %regex~(stbi_hdr_to_ldr_gamma|stbi_hdr_to_ldr_scale|stbi_ldr_to_hdr_gamma|stbi_ldr_to_hdr_scale)$%%),
        group_by_regex("File writing", mod, %regex~(stbi_write_png|stbi_write_bmp|stbi_write_tga|stbi_write_jpg|stbi_write_hdr)$%%),
        group_by_regex("Write to memory", mod, %regex~(stbi_write_png_to_memory|stbi_write_bmp_to_memory|stbi_write_tga_to_memory|stbi_write_jpg_to_memory)$%%),
        group_by_regex("Write settings", mod, %regex~(stbi_flip_vertically_on_write|stbi_write_set_.*|stbi_write_get_.*)$%%),
        group_by_regex("Image resizing", mod, %regex~(stbir_resize|stbir_resize_uint8_srgb|stbir_resize_uint8_linear|stbir_resize_float_linear)$%%),
        group_by_regex("Animated PNG (APNG) writer", mod, %regex~stbi_apng_(begin|frame|end|dropped)$%%)
    )
    document("Image loading, writing, and resizing (stb_image)", mod, "stbimage.rst", groups)
}

def document_module_raster(_root : string) {
    var mod = get_module("raster")
    var groups <- array<DocGroup>(
        group_by_regex("Gather", mod, %regex~gather$%%),
        group_by_regex("Scatter", mod, %regex~scatter$%%),
        group_by_regex("Scatter with mask", mod, %regex~scatter_neq_mask$%%),
        group_by_regex("Store with mask", mod, %regex~store_neq_mask$%%),
        group_by_regex("Gather-scatter", mod, %regex~gather_scatter$%%),
        group_by_regex("Gather-scatter with mask", mod, %regex~gather_scatter_neq_mask$%%),
        group_by_regex("Gather-store with mask", mod, %regex~gather_store_neq_mask$%%),
        group_by_regex("Gather-store with stride", mod, %regex~gather_store_stride$%%),
        group_by_regex("Byte gather-store", mod, %regex~u8x4_gather_store$%%),
        group_by_regex("Copy reversed", mod, %regex~rast_copy_reversed_.*$%%),
        group_by_regex("Copy rect", mod, %regex~rast_copy_rect_.*$%%),
        group_by_regex("Channel conversion", mod, %regex~rast_convert_channels_.*$%%),
        group_by_regex("BPC conversion", mod, %regex~rast_convert_.*_to_.*$%%),
        group_by_regex("Span raster", mod, %regex~rast_hspan.*$%%),
        group_by_regex("Fill rect", mod, %regex~rast_fill_rect_.*$%%),
        group_by_regex("Alpha blit", mod, %regex~rast_blit_alpha$%%)
    )
    document("Raster operations (pixel copy, convert, SIMD gather/scatter)", mod, "raster.rst", groups)
}

def document_module_stbimage_boost(_root : string) {
    var mod = find_module("stbimage_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Image construction", mod, %regex~(make_image)$%%),
        group_by_regex("Image loading", mod, %regex~(load_image|image_info|is_hdr|is_16_bit|is_hdr_from_memory|is_16_bit_from_memory)$%%),
        group_by_regex("Pixel access", mod, %regex~(with_pixels|with_pixels_f|with_pixels_16|with_row|with_row_f|with_row_16)$%%),
        group_by_regex("Drawing", mod, %regex~.*(fill_rect|blit_alpha|blit)$%%),
        group_by_regex("Format conversion", mod, %regex~.*(to_channels|to_bpc)$%%),
        group_by_regex("Transforms", mod, %regex~.*(resize|flip_vertical|flip_horizontal|crop)$%%),
        group_by_regex("Save and encode", mod, %regex~.*(save|encode)$%%),
        group_by_regex("Image properties", mod, %regex~.*(valid|stride|has_alpha|pixel_size|is_hdr|data_size)$%%),
        group_by_regex("Image loading (methods)", mod, %regex~.*(load|load_hdr|load_16|load_from_memory|load_hdr_from_memory|load_16_from_memory)$%%)
    )
    document("High-level image API (stbimage_boost)", mod, "stbimage_boost.rst", groups)
}

def document_module_stbtruetype(_root : string) {
    var mod = get_module("stbtruetype")
    var groups <- array<DocGroup>(
        group_by_regex("Font loading", mod, %regex~.*(GetNumberOfFonts|GetFontOffsetForIndex|InitFont)$%%),
        group_by_regex("Font packing", mod, %regex~.*(PackBegin|PackEnd|PackFontRange|PackSetOversampling|PackSetSkipMissingCodepoints|GetPackedQuad)$%%),
        group_by_regex("Font metrics", mod, %regex~.*(ScaleForPixelHeight|ScaleForMappingEmToPixels|GetFontVMetrics|GetFontBoundingBox)$%%),
        group_by_regex("Codepoint metrics", mod, %regex~.*(GetCodepointHMetrics|GetCodepointKernAdvance|GetCodepointBox|FindGlyphIndex)$%%),
        group_by_regex("Codepoint bitmaps", mod, %regex~.*(GetCodepointBitmap|GetCodepointBitmapSubpixel|MakeCodepointBitmap|MakeCodepointBitmapSubpixel|GetCodepointBitmapBox|GetCodepointBitmapBoxSubpixel|FreeBitmap)$%%),
        group_by_regex("Glyph shape", mod, %regex~.*(GetCodepointShape|GetCodepointShape_count)$%%)
    )
    document("TrueType font loading and rasterization (stb_truetype)", mod, "stbtruetype.rst", groups)
}

def document_module_stbimage_ttf(_root : string) {
    var mod = find_module("stbimage_ttf")
    var groups <- array<DocGroup>(
        // Low-level safe wrappers (stbtt_fontinfo)
        group_by_regex("Low-level initialization", mod, %regex~(stbtt_init|stbtt_num_fonts)$%%),
        group_by_regex("Low-level scale", mod, %regex~(stbtt_scale_for_pixel_height|stbtt_scale_for_em)$%%),
        group_by_regex("Low-level metrics", mod, %regex~(stbtt_font_vmetrics|stbtt_font_bbox|stbtt_codepoint_hmetrics|stbtt_codepoint_kern|stbtt_codepoint_box|stbtt_find_glyph)$%%),
        group_by_regex("Low-level glyph shape", mod, %regex~(stbtt_codepoint_shape|stbtt_codepoint_shape_count)$%%),
        group_by_regex("Low-level bitmap rendering", mod, %regex~(stbtt_codepoint_bitmap_box|stbtt_codepoint_bitmap_box_subpixel|stbtt_codepoint_bitmap|stbtt_codepoint_bitmap_subpixel|stbtt_make_codepoint_bitmap|stbtt_make_codepoint_bitmap_subpixel)$%%),
        group_by_regex("Low-level packing", mod, %regex~(stbtt_pack|stbtt_packed_quad)$%%),
        // Font API (high-level)
        group_by_regex("Font loading", mod, %regex~^(load_font|load_ttf|is_valid)$%%),
        group_by_regex("Font scale", mod, %regex~^(scale_for_pixel_height|scale_for_em)$%%),
        group_by_regex("Font metrics", mod, %regex~^(font_vmetrics|font_metrics|font_bounding_box|codepoint_hmetrics|codepoint_kern|codepoint_box|find_glyph)$%%),
        group_by_regex("Font glyph shape", mod, %regex~^(codepoint_shape|codepoint_shape_count)$%%),
        group_by_regex("Font bitmap rendering", mod, %regex~^(codepoint_bitmap_box|codepoint_bitmap_box_subpixel|codepoint_bitmap|codepoint_bitmap_subpixel)$%%),
        group_by_regex("Text measurement and rendering", mod, %regex~^(measure_text|render_text)$%%)
    )
    document("TrueType font API (stbimage_ttf)", mod, "stbimage_ttf.rst", groups)
}

def document_module_audio(_root : string) {
    var mod = get_module("audio")
    var groups <- array<DocGroup>(
        group_by_regex("Audio device", mod, %regex~(sound_initalize|sound_finalize|mixer_context|sound_set_null_device|audio_is_single_threaded)$%%),
        group_by_regex("Capture", mod, %regex~(sound_record|sound_is_recording)%%),
        group_by_regex("Decoder", mod, %regex~ma_decoder%%),
        group_by_regex("Resampler", mod, %regex~ma_resampler%%),
        group_by_regex("Channel converter", mod, %regex~ma_channel_converter%%),
        group_by_regex("Volume mixer", mod, %regex~ma_volume_mixer%%),
        group_by_regex("Limiter", mod, %regex~ma_limiter%%),
        group_by_regex("HRTF", mod, %regex~ma_hrtf%%),
        group_by_regex("I3DL2 Reverb", mod, %regex~(set_sample_rate|set_properties|process_stereo|process_mono|get_preset)$%%),
        group_by_regex("Convolution Reverb", mod, %regex~conv_reverb%%),
        group_by_regex("Chorus", mod, %regex~chorus%%),
        group_by_regex("Delay", mod, %regex~delay_%%),
        group_by_regex("Per-voice effects", mod, %regex~.*(bandpass|bitcrush|compressor|djfilter|phaser|tremolo|waveshaper)_(init|process|setup)$%%),
        group_by_regex("Per-voice effect types", mod, %regex~ma_(bandpass|bitcrush|compressor|djfilter|phaser|tremolo|waveshaper)$%%),
        group_by_regex("SF2 voice", mod, %regex~ma_sf2%%),
        group_by_regex("Enumerations and constants", mod, %regex~MA_SAMPLE_RATE$%%)
    )
    document("Low-level audio bindings (miniaudio)", mod, "audio.rst", groups)
}

def document_module_audio_boost(_root : string) {
    var mod = find_module("audio_boost")
    var groups <- array<DocGroup>(
        group_by_regex("Audio system lifecycle", mod, %regex~(with_audio_system|audio_system_create|audio_system_finalize|audio_system_release_context)$%%),
        group_by_regex("Sound playback", mod, %regex~(play_sound|play_3d_sound)%%),
        group_by_regex("Sound control", mod, %regex~(set_volume|set_pan|set_pitch|set_pause|set_global_pitch|set_global_pause|set_global_volume|set_ignore_global_volume|stop|set_playback_position)$%%),
        group_by_regex("3D audio", mod, %regex~(set_head_position|set_position)$%%),
        group_by_regex("HRTF", mod, %regex~(hrtf_budget_classify|set_hrtf_budget)$%%),
        group_by_regex("Reverb", mod, %regex~(set_reverb|set_reverb_preset)$%%),
        group_by_regex("Chorus", mod, %regex~(set_chorus|set_chorus_default)$%%),
        group_by_regex("Attenuation", mod, %regex~(compute_attenuation|default_attenuation|inverse_distance_attenuation|linear_attenuation|quadratic_attenuation|inverse_square_attenuation)$%%),
        group_by_regex("Status monitoring", mod, %regex~(set_status_update|clear_status|unset_status_update|set_audio_stats_box)$%%),
        group_by_regex("Command batching", mod, %regex~(begin_batch|end_batch|batch)$%%),
        group_by_regex("PCM stream", mod, %regex~(append_to_pcm|append_box_to_pcm)$%%),
        group_by_regex("Decoding", mod, %regex~(decode_audio)$%%),
        group_by_regex("Sound ID", mod, %regex~(generate_sound_sid)$%%),
        group_by_regex("Internal stream management", mod, %regex~(get_audio_command_stream|set_audio_thread_command_stream|get_sound_sid|set_sound_sid)$%%)
    )
    document("Audio playback, mixing, 3D spatial audio, and effects", mod, "audio_boost.rst", groups)
}

def document_module_audio_wav(_root : string) {
    var mod = find_module("audio_wav")
    var groups <- array<DocGroup>(
        group_by_regex("WAV I/O", mod, %regex~(read_wav|write_wav)$%%)
    )
    document("WAV file reading and writing", mod, "audio_wav.rst", groups)
}

def document_module_audio_record(_root : string) {
    var mod = find_module("audio_record")
    var groups <- array<DocGroup>(
        group_by_regex("Recording", mod, %regex~(sound_record_list_devices|record_to_wav)$%%)
    )
    document("Microphone capture and record-to-WAV", mod, "audio_record.rst", groups)
}

def document_module_strudel_event(_root : string) {
    var mod = find_module("strudel_event")
    var groups <- array<DocGroup>(
        group_by_regex("ADSR and delay resolution", mod, %regex~(resolve_adsr|resolve_delaytime)$%%)
    )
    document("Event payload and ADSR/delay-time resolvers", mod, "strudel_event.rst", groups)
}

def document_module_strudel_time(_root : string) {
    var mod = find_module("strudel_time")
    var groups <- array<DocGroup>(
        group_by_regex("Cycle math", mod, %regex~(cyclePos|sameCycle|splitSpans)$%%)
    )
    document("Cycle-space time primitives: TimeSpan, Hap, and cycle helpers", mod, "strudel_time.rst", groups)
}

def document_module_strudel_live(_root : string) {
    var mod = find_module("strudel_live")
    var groups <- array<DocGroup>(
        group_by_regex("Live-reload state", mod, %regex~(save_strudel_state|restore_strudel_state)$%%)
    )
    document("Live-reload state preservation", mod, "strudel_live.rst", groups)
}

def document_module_strudel_scales(_root : string) {
    var mod = find_module("strudel_scales")
    var groups <- array<DocGroup>(
        group_by_regex("Scale and note selection", mod, %regex~(scale|set_scale|scale_pattern|get_scale_intervals_by_name|degree_to_note|parse_root)$%%)
    )
    document("Musical scales and note-name helpers", mod, "strudel_scales.rst", groups)
}

def document_module_strudel_mini(_root : string) {
    var mod = find_module("strudel_mini")
    var groups <- array<DocGroup>(
        group_by_regex("Tokenizer and parser", mod, %regex~(tokenize|parse_note_name|parse_note_name_default)$%%),
        group_by_regex("Fluent DSL constructors", mod, %regex~(s|n|note_pattern|seq|note|vowel|set_s|set_vowel)$%%),
        group_by_regex("Cycle-rate variants", mod, %regex~(every_fast|every_slow|every_degrade)$%%)
    )
    document("Mini-notation tokenizer, parser, and fluent-DSL entry points", mod, "strudel_mini.rst", groups)
}

def document_module_strudel_samples(_root : string) {
    var mod = find_module("strudel_samples")
    var groups <- array<DocGroup>(
        group_by_regex("Loading", mod, %regex~(load_audio_file|load_sound|load_audio_memory|load_sound_memory)$%%),
        group_by_regex("Rendering", mod, %regex~(render_sample)$%%)
    )
    document("Sample bank and audio file loading", mod, "strudel_samples.rst", groups)
}

def document_module_strudel_synth(_root : string) {
    var mod = find_module("strudel_synth")
    var groups <- array<DocGroup>(
        group_by_regex("Pitch conversion", mod, %regex~(note_to_freq)$%%),
        group_by_regex("Noise generators", mod, %regex~(noise)$%%),
        group_by_regex("Drum renderers", mod, %regex~render_(bd|sd|hh|cp|oh|tom|ride|crash|rimshot|cowbell|tambourine)$%%),
        group_by_regex("Oscillator type", mod, %regex~(to_osc_type)$%%),
        group_by_regex("Voice FX chain", mod, %regex~(fx_init_from_event|fx_apply|fx_apply_to_samples)$%%),
        group_by_regex("Oscillator voice", mod, %regex~(osc_voice_init_supersaw|osc_voice_init_filters|osc_render_chunk)$%%),
        group_by_regex("Vowel filter", mod, %regex~(vowel_get_formant_data|vowel_filter_init|vowel_filter_tick|formant_biquad_setup_bpf|formant_biquad_tick)$%%),
        group_by_regex("Voice rendering", mod, %regex~(render_event_stereo|mono_to_stereo)$%%)
    )
    document("Audio synthesis: oscillators, drums, filters, and effects", mod, "strudel_synth.rst", groups)
}

def document_module_strudel_scheduler(_root : string) {
    var mod = find_module("strudel_scheduler")
    var groups <- array<DocGroup>(
        group_by_regex("Orbit effects", mod, %regex~(init_reverb|init_delay|get_orbit_reverb|get_orbit_delay|get_orbit_chorus)$%%),
        group_by_regex("Orbit levels", mod, %regex~(fade_orbit|set_orbit_gain|orbit_gain|advance_orbit_gains)$%%),
        group_by_regex("Reverb quality override", mod, %regex~(set_force_reverb_quality|set_force_reverb_stages)$%%),
        group_by_regex("Scheduler lifecycle", mod, %regex~(tick|shutdown_scheduler|finalize)$%%)
    )
    document("Voice allocation, effect bus routing, and per-tick mixing", mod, "strudel_scheduler.rst", groups)
}

def document_module_strudel_player(_root : string) {
    var mod = find_module("strudel_player")
    var groups <- array<DocGroup>(
        group_by_regex("Lifecycle", mod, %regex~strudel_(init|shutdown|create_channel)$%%),
        group_by_regex("Playback control", mod, %regex~strudel_(play|stop|set_pause|is_playing|noop_cmd|tick|tick_offline|command)$%%),
        group_by_regex("Tempo and timing", mod, %regex~strudel_(set_bpm|set_cps|get_bpm|get_cps|get_playback_time|set_look_ahead)$%%),
        group_by_regex("Volume", mod, %regex~strudel_(set_volume|get_volume)$%%),
        group_by_regex("Asset loading", mod, %regex~strudel_(load_sound|load_sample_dir|load_sf2|get_sf2_path|has_sf2)$%%),
        group_by_regex("Track management", mod, %regex~strudel_(add_track|add_track_immediate|remove_track|fade_track)$%%),
        group_by_regex("One-shots", mod, %regex~strudel_(one_shot|active_tracks)$%%),
        group_by_regex("Orbit levels", mod, %regex~strudel_(fade_orbit|set_orbit_gain|orbit_gain)$%%),
        group_by_regex("State serialization", mod, %regex~strudel_(save_state|restore_state|save_sf2_state|restore_sf2_state)$%%),
        group_by_regex("Debug and diagnostics", mod, %regex~strudel_(debug_memory|reset_memory_baseline|debug_sample_peaks|debug_master_peak|debug_output_peak|debug_voices)$%%)
    )
    document("Top-level playback harness: tracks, BPM/CPS, and threaded audio", mod, "strudel_player.rst", groups)
}

def document_module_strudel_midi(_root : string) {
    var mod = find_module("strudel_midi")
    var groups <- array<DocGroup>(
        group_by_regex("Parsing", mod, %regex~(parse_midi|load_midi|parse_midi_track)$%%),
        group_by_regex("Track operations", mod, %regex~(merge_tracks)$%%),
        group_by_regex("Binary readers", mod, %regex~(read_byte|read_u16|read_u32|read_vlq)$%%)
    )
    document("MIDI file parser", mod, "strudel_midi.rst", groups)
}

def document_module_strudel_midi_player(_root : string) {
    var mod = find_module("strudel_midi_player")
    var groups <- array<DocGroup>(
        group_by_regex("Lifecycle", mod, %regex~midi_(init|shutdown|init_reverb)$%%),
        group_by_regex("Playback control", mod, %regex~midi_(play|play_data|stop|set_pause|is_playing|tick)$%%),
        group_by_regex("Audio setup", mod, %regex~midi_(set_volume|set_audio_vis_channel)$%%),
        group_by_regex("Asset loading", mod, %regex~midi_(load_samples|load_sf2)$%%),
        group_by_regex("Event processing", mod, %regex~(init_playback|process_events)$%%),
        group_by_regex("Drum and GM preset rendering", mod, %regex~(render_drum_hit|gm_preset|midi_adsr)$%%)
    )
    document("MIDI file playback with GM preset mapping", mod, "strudel_midi_player.rst", groups)
}

def document_module_strudel_sf2(_root : string) {
    var mod = find_module("strudel_sf2")
    var groups <- array<DocGroup>(
        group_by_regex("Loading", mod, %regex~(sf2_load|sf2_parse)$%%),
        group_by_regex("Preset and zone lookup", mod, %regex~(sf2_find_preset|sf2_find_zones)$%%),
        group_by_regex("Generator access", mod, %regex~(has_generator|get_generator|get_generator_range)$%%),
        group_by_regex("Unit conversion", mod, %regex~(timecents_to_seconds|cents_to_hz|centibels_to_linear)$%%),
        group_by_regex("Modulator source helpers", mod, %regex~(sf2_mod_src)%%),
        hide_group(group_by_regex("Internal finalize infrastructure", mod, %regex~finalize%%))
    )
    document("SoundFont 2 file parser", mod, "strudel_sf2.rst", groups)
}

def document_module_strudel_sf2_voice(_root : string) {
    var mod = find_module("strudel_sf2_voice")
    var groups <- array<DocGroup>(
        group_by_regex("Envelope", mod, %regex~sf2_env_(start|tick)$%%),
        group_by_regex("LFO", mod, %regex~sf2_lfo_tick$%%),
        group_by_regex("Modulators", mod, %regex~sf2_(velocity_attenuation|mod_get_value|apply_modulators|mod_identity_match|apply_default_modulators|default_cc_values|collect_atten_modulators|recalc_atten)$%%),
        group_by_regex("Voice creation", mod, %regex~sf2_(create_c_voice|get_exclusive_class|get_reverb_send|get_chorus_send)$%%)
    )
    document("SoundFont 2 per-voice runtime: envelope, LFO, modulators, biquad", mod, "strudel_sf2_voice.rst", groups)
}

def document_module_strudel_pattern(_root : string) {
    var mod = find_module("strudel_pattern")
    var groups <- array<DocGroup>(
        group_by_regex("Pattern construction", mod, %regex~(pure|silence|atom|querySpan|queryArc|patternType)$%%),
        group_by_regex("Time manipulation", mod, %regex~(fast|slow|stack|cat|fastcat|weighted_fastcat|fmap)$%%),
        group_by_regex("Combinators", mod, %regex~(rev|jux|off|layer|superimpose|euclid|euclidRot|palindrome|ply|iter|iterBack|when_cycle|linger|hurry|compress|chunk|striate|chop|slice|struct_|mask|choose|wchoose|randcat|chooseCycles|shuffle|scramble|echo|stut|transpose|add|innerJoin|combineWith|combineWithStr|degrade|degradeBy|every|bjorklund|sometimes|often|sometimesby|playFor|once)$%%),
        group_by_regex("Setter primitives", mod, %regex~set_.*$%%),
        group_by_regex("Fluent control: dynamics and routing", mod, %regex~(gain|velocity|vel|pan|speed|note|freq|sound|cut|orbit|begin|end_pos)$%%),
        group_by_regex("Fluent control: 3D positioning (HRTF)", mod, %regex~(hrtf|hrtf_azimuth|hrtf_elevation)$%%),
        group_by_regex("Fluent control: effects sends", mod, %regex~(room|roomquality|roomstages|roomsize|size|delay|delaytime|dt|delayfeedback|dfb|delaysync|chorus)$%%),
        group_by_regex("Fluent control: filters", mod, %regex~(lpf|lp|hpf|hp|lpq|resonance|hpq|bpf|bpq|djf)$%%),
        group_by_regex("Fluent control: envelope", mod, %regex~(attack|att|decay|dec|sustain|sus|release|rel)$%%),
        group_by_regex("Fluent control: synthesis and shaping", mod, %regex~(fm|fmh|crush|coarse|shape)$%%),
        group_by_regex("Fluent control: modulation FX", mod, %regex~(phaser|ph|phaserdepth|phd|phasercenter|phc|phasersweep|phs|tremolo|trem|tremolodepth|tremdepth|compressor.*)$%%),
        group_by_regex("Fluent control: SF2", mod, %regex~sf2.*$%%),
        group_by_regex("Signals", mod, %regex~(signal|signal_.*|sine|cosine|saw|tri|perlin|range|square|isaw|itri|sine2|cosine2|saw2|tri2|square2|isaw2|itri2|rand|rand2|irand|run)$%%),
        // public only so union-widened combinators' captured lambdas resolve them
        // cross-module — not user-facing API
        hide_group(group_by_regex("Internal", mod, %regex~(strudel_hash01|strudel_hash32)$%%))
    )
    document("Pattern algebra, combinators, and fluent control API", mod, "strudel_pattern.rst", groups)
}

def document_module_peg(_root : string) {
    var mod = find_module("peg")
    var groups <- array<DocGroup>(
        group_by_regex("Matching primitives", mod, %regex~.*(matches|move|reached_EOF|reached_EOL|get_current_char)$%%),
        group_by_regex("Whitespace", mod, %regex~.*(skip_whitespace|skip_taborspace)$%%),
        group_by_regex("Literal matching", mod, %regex~.*(match_decimal_literal|match_string_literal|match_double_literal)$%%),
        group_by_regex("Tracing and logging", mod, %regex~.*(tabulate|log_plain|log_fail|log_success|log_info)$%%),
        hide_group(group_by_regex("ParsingError operators", mod, %regex~^(!=|<)$%%)),
        hide_group(group_by_regex("Internal", mod, %regex~.*(at_around)$%%))
    )
    document("PEG parser generator", mod, "peg.rst", groups)
}

def document_module_spirv(_root : string) {
    var mod = find_module("spirv_reflect")
    var groups <- array<DocGroup>(
        group_by_regex("Reflection types", mod, %regex~(SpirvReflection|SpirvDescriptorBinding|SpirvPushConstantRange|SpirvDescriptorKind|SpirvStageFlags)$%%),
        group_by_regex("Serialization", mod, %regex~(encode_reflection|decode_reflection)$%%),
        hide_group(group_by_regex("Internal finalize infrastructure", mod, %regex~finalize%%))
    )
    document("SPIR-V shader reflection (dasSpirv): API-neutral descriptor + push-constant layout, host-consumed", mod, "spirv_reflect.rst", groups)
}

def document_module_gltf(_root : string) {
    // The backend-neutral core only (gltf_types/accessor/parse/scene). The opt-in GL adapter
    // (gltf_gl/gltf_pbr) requires dasOpenGL, which this doc generator does not load.
    var mod = [find_module("gltf_types"), find_module("gltf_accessor"),
        find_module("gltf_parse"), find_module("gltf_scene")]
    var groups <- array<DocGroup>(
        group_by_regex("Loading", mod, %regex~.*(load_gltf|load_gltf_from_memory)$%%),
        group_by_regex("Scene, skinning and animation", mod, %regex~.*(update_world_transforms|gltf_scene_bounds|evaluate_animation|gltf_joint_matrix)$%%),
        group_by_regex("Accessor byte readers", mod, %regex~.*(gltf_rd_.*|gltf_read_comp_.*|gltf_comp_size|gltf_type_ncomp)$%%),
        hide_group(group_by_regex("Internal finalize infrastructure", mod, %regex~finalize%%))
    )
    documents("glTF 2.0 loader (dasGLTF): GLB/.gltf parse, accessor decode, node hierarchy, skinning and keyframe animation into a backend-neutral scene", mod, "gltf.rst", groups)
}

// das2rst compiles tuned libraries to inspect their source API. The explicit
// documentation context keeps all [tune] transforms and policy machinery inert.
[export]
def main {
    disable_profiler(this_context())
    disable_profiler_log(this_context())
    ast_gc_guard() {
    let root = get_das_root() + "/doc/source/stdlib/generated"
    // document embedded modules
    document_module_builtin(root)
    document_module_math(root)
    document_module_fio(root)
    document_module_clipboard(root)
    document_module_network(root)
    document_module_dashv(root)
    document_module_openai(root)
    document_module_stbimage(root)
    document_module_raster(root)
    document_module_stbtruetype(root)
    document_module_uriparser(root)
    document_module_pugixml(root)
    document_module_audio(root)
    // document dasAudio daScript modules
    document_module_audio_boost(root)
    document_module_audio_wav(root)
    document_module_audio_record(root)
    // document strudel modules
    document_module_strudel_event(root)
    document_module_strudel_time(root)
    document_module_strudel_live(root)
    document_module_strudel_scales(root)
    document_module_strudel_mini(root)
    document_module_strudel_samples(root)
    document_module_strudel_synth(root)
    document_module_strudel_scheduler(root)
    document_module_strudel_player(root)
    document_module_strudel_midi(root)
    document_module_strudel_midi_player(root)
    document_module_strudel_sf2(root)
    document_module_strudel_sf2_voice(root)
    document_module_strudel_pattern(root)
    // document dasPEG module
    document_module_peg(root)
    document_module_gltf(root)
    // document dasSpirv reflection module
    document_module_spirv(root)
    // document the dasLLAMA facade module (the engine modules behind it stay undocumented by design)
    document_module_dasllama(root)
    document_module_debugapi(root)
    document_module_rtti(root)
    document_module_ast(root)
    document_module_strings(root)
    document_module_jobque(root)
    // document daslib modules
    document_module_algorithm(root)
    document_module_ansi_colors(root)
    document_module_tty(root)
    document_module_apply_in_context(root)
    document_module_apply(root)
    document_module_archive(root)
    document_module_array_boost(root)
    document_module_assert_once(root)
    document_module_ast_block_to_loop(root)
    document_module_ast_boost(root)
    document_module_ast_cursor(root)
    document_module_ast_used(root)
    document_module_ast_match(root)
    document_module_async_boost(root)
    document_module_base64(root)
    document_module_bitfield_boost(root)
    document_module_bitfield_trait(root)
    document_module_bool_array(root)
    document_module_class_boost(root)
    document_module_command_line(root)
    document_module_constexpr(root)
    document_module_consume(root)
    document_module_contracts(root)
    document_module_coroutines(root)
    // document_module_coverage(root)              // [infer_macro] modifies AST of all modules
    document_module_cpp_bind(root)
    document_module_cuckoo_hash_table(root)
    document_module_dap(root)
    document_module_das_source_formatter(root)
    document_module_das_source_formatter_fio(root)
    document_module_dashv_boost(root)
    // document_module_debug(root)                 // uses persistent_heap, complex deps
    document_module_debug_eval(root)
    document_module_decs(root)
    document_module_decs_boost(root)
    document_module_decs_state(root)
    document_module_defer(root)
    document_module_with_boost(root)
    document_module_delegate(root)
    document_module_dynamic_cast_rtti(root)
    document_module_enum_trait(root)
    document_module_faker(root)
    document_module_flat_hash_table(root)
    document_module_functional(root)
    document_module_fuzzer(root)
    document_module_generic_return(root)
    // document_module_heartbeat(root)              // qmacro(heartbeat()) conflicts when used in das2rst context
    document_module_if_not_null(root)
    document_module_instance_function(root)
    document_module_interfaces(root)
    document_module_is_local(root)
    document_module_jobque_boost(root)
    document_module_jobque_profile(root)
    document_module_json_boost(root)
    document_module_json(root)
    document_module_jsonrpc(root)
    // document_module_linked_list(root)         // spoof template, not documentable
    document_module_linq(root)
    document_module_linq_boost(root)
    document_module_linq_fold(root)
    document_module_lint(root)
    document_module_lint_config(root)
    document_module_toml(root)
    document_module_logger(root)
    // document_module_lint_everything(root)       // global_lint_macro causes lint errors in other modules
    // document_module_live(root)                  // uses multiple_contexts
    document_module_lpipe(root)
    document_module_macro_boost(root)
    document_module_md_boost(root)
    document_module_match(root)
    document_module_math_bits(root)
    document_module_math_boost(root)
    document_module_option(root)
    document_module_profiler(root)
    document_module_profiler_boost(root)
    document_module_PUGIXML_boost(root)
    document_module_quote(root)
    document_module_random(root)
    document_module_refactor(root)
    document_module_regex_boost(root)
    document_module_regex(root)
    document_module_remove_call_args(root)
    document_module_result(root)
    document_module_rst(root)
    document_module_safe_addr(root)
    document_module_soa(root)
    document_module_sort_boost(root)
    document_module_static_let(root)
    document_module_stbimage_boost(root)
    document_module_stbimage_ttf(root)
    document_module_stringify(root)
    document_module_strings_boost(root)
    document_module_strings_convert(root)
    document_module_temp_strings(root)
    document_module_templates_boost(root)
    document_module_templates(root)
    document_module_type_traits(root)
    document_module_typemacro_boost(root)
    document_module_unroll(root)
    document_module_uriparser_boost(root)
    document_module_utf8_utils(root)
    document_module_validate_code(root)
    }
}