Data Structures

Here are the data structures with brief descriptions:

[detail level 123]

Nascii_query
Njson
CJsonValue	JSON value wrapper (can hold any JSON type)
CJsonArray	JSON array builder
CJsonObject	JSON object builder
CHttpRequest	Parsed HTTP request
CHttpResponse	HTTP response builder
CHttpServer	Simple single-threaded HTTP server
CThreadInfo	Thread information
CFrameInfo	Stack frame information
CVariableInfo	Variable information (from LLDB SBValue)
CBreakpointInfo	Breakpoint information
CLLDBController	LLDB process controller
C__attribute__	Network quality metrics for a single participant
Cacds_client_config_t	Acds client config is intentionally a small, concrete record. Fields such as server_port, timeout_ms, security_policy, identity_key give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cacds_client_data_t	Network statistics for both TCP and WebSocket connections
Cacds_client_t	ACDS client connection handle
Cacds_config_t	Discovery server configuration
Cacds_create_key_set_t	The useful part of acds create key set is in request, count: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. request and reserved_string are adjacent to preserve the legacy trailing name
Cacds_handoff_entry	Background thread for periodic cleanup
Cacds_hash_entry_t	Hash table entry for ACDS packet type to handler mapping
Cacds_protocol
Cacds_server_t	Discovery server state
Cacds_session_create_params_t	Session creation request parameters
Cacds_session_create_result_t	Session creation result
Cacds_session_join_params_t	Session join parameters
Cacds_session_join_result_t	Session join result
Cacds_session_lookup_result_t	Session lookup result
Cacds_stats_t	For acds client data, this is the live record that ties joined_session, negotiation, create_transport_length, create_keys together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cacds_thread_context_t	Context for ACDS discovery thread
Cacip_acds_callbacks_t	ACDS packet handler callbacks
Cacip_client_callbacks_t	Client-side packet handler callbacks
Cacip_frame_workspace_t	Send ASCII frame to client (server → client)
Cacip_outbound
Cacip_outbound_stats_t	This is the handoff point for acip outbound stats. Callers fill application_bytes, backend_bytes, backend_reserved_bytes, peak_bytes before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cacip_packet_plan_t
Cacip_render_settings_t	Acip render settings keeps the values that move through the subsystem: caps, width, height, revision. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cacip_security	Acip security is intentionally a small, concrete record. Fields such as handshake, mode, forbid_encryption, require_encryption give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed. Callers serialize receive/start and keep the transport alive until cleanup. Media must wait for ready, including authentication-only connections
Cacip_send_options_t
Cacip_server_callbacks_t	Server-side packet handler callbacks
Cacip_settings_header_t	Acip settings header keeps the values that move through the subsystem: schema, request, expected_revision, revision. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cacip_transport	Transport instance structure
Cacip_transport_capabilities_t	The useful part of acip transport capabilities is in independent_streams, datagrams, max_datagram_payload: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. application data in one QUIC DATAGRAM frame on the current path, including any transport-specific envelope. Query again after path changes
Cacip_transport_methods_t	Transport method table (virtual function table)
Cacip_websocket_runtime
Caction_args_t	Action argument structure
Cadaptive_sleep_config_t	Configuration for adaptive sleep behavior
Cadaptive_sleep_state_t	Runtime state for adaptive sleep
Canchor_list	Vector type for trust anchors
Canimation_config_t
Canimation_sample_t	For animation config, this is the live record that ties type, fps, speed, hidden_policy together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Canimation_t
Canimation_target_t
Cansi_rle_context_t
Cansi_timing_t
Capi_render_job
Capi_server_t
Capp_callbacks_t
Cascii_frame_packet_t	The wire metadata for one rendered ASCII frame. width and height describe the terminal grid, original_size and compressed_size bound the encoded text, and checksum detects corruption; flags carry frame-specific options. The variable text follows this fixed prefix and is owned by the packet storage until decoding completes
Cascii_frame_source_t	Frame source structure for grid layout
Cascii_frame_t	When code needs to work with ascii frame, it keeps output, output_target, width, source_height here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cascii_otel_scope	Ascii otel scope is intentionally a small, concrete record. Fields such as scope, retained, previous give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cascii_stabilizer_t
Cascii_temporal_cell_t	For ascii stabilizer, this is the live record that ties cells, width, height, configuration together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Casciichat_errno_history_t
Casciichat_errno_scope_t	When code needs to work with asciichat errno snapshot, it keeps total, copied here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Casciichat_errno_snapshot_t
Casciichat_error_context_t
Casciichat_error_stats_t
Casciichat_instr_only_list	Dynamic array of instrumentation selectors for filtering output
Casciichat_instr_only_selector	Selector for filtering instrumentation output by file, function, or module
Casciichat_instr_runtime	Per-thread instrumentation runtime state
Casciichat_mdns_discovery_t	Service information for advertisement
Casciichat_mdns_service_t	Service information for advertisement
Casciichat_mdns_t	Owns one mDNS browse or advertisement session, including its socket, event-loop registration, discovered
Casync_packet
Casync_tcp_t
Caudio_analysis_stats_t	Measurements used to diagnose sent or received audio quality
Caudio_batch_info_t	Parsed audio batch packet header information
Caudio_batch_packet_t	The metadata prefix for a batch of encoded audio samples. batch_count, total_samples, sample_rate, and channels let the receiver allocate or route the batch correctly before it touches the encoded payload. The header is serialized with the packet; the audio bytes remain in the enclosing packet buffer
Caudio_context_t	When code needs to work with audio device info, it keeps index, max_input_channels, max_output_channels, default_sample_rate here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Caudio_device_info_t	Audio device information structure
Caudio_processor	For audio processor, this is the live record that ties config, spectral_left, spectral_right, compressor together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Caudio_processor_config_t
Caudio_processor_flags_t	Audio processor config keeps the values that move through the subsystem: channels, sample_rate, flags, spectral_enabled. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Caudio_recording	The useful part of audio recording is in mix, channels, epoch_ns, read_position: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Caudio_resampler_t	When code needs to work with audio resampler, it keeps phase, has_previous here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Caudio_ring_buffer	Audio ring buffer for real-time audio streaming
Caudio_rt_metric_t
Caudio_send_packet_t
CAudioProcessorBinding
Cauth_failure_packet_t	Authentication failure packet structure
CAVStateBinding
Cbinary_actions_t
Cbinary_level_opts_t	Create a new options_t struct with all defaults set
Cbinding_t
Cbroadcast_context_t	Context for broadcasting to session participants
Cbrowser_peer_crypto
CBrowserHostState
Cbuffer_budget_t	Owns the temporary storage used by buffer budget. The data pointers and size or cursor fields describe the live portion of the allocation; callers must use the type's cleanup path when the buffer or queue is no longer needed
Cbuffer_domain	The useful part of buffer header is in next, domain, allocation, data: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cbuffer_domain_config_t
Cbuffer_header
Cbuffer_stats_t
Cbuffer_workspace_t	Owns the temporary storage used by buffer workspace. The data pointers and size or cursor fields describe the live portion of the allocation; callers must use the type's cleanup path when the buffer or queue is no longer needed
Cbvector	Dynamic byte vector for PEM decoding
Ccategory_builder_t	Registry entry - stores option definition with mode bitmask and metadata
Cclient_audio_pipeline_config_t	Pipeline configuration parameters
Cclient_audio_pipeline_flags_t	Component enable/disable flags
Cclient_audio_pipeline_t	Client audio pipeline state
Cclient_connection
Cclient_dispatch_entry_t	Hash table entry for client packet dispatch
Cclient_info
Cclient_info_packet_t	Client information packet structure
Cclient_like_state_t
Cclient_list_packet_t	Snapshot of the clients currently known to the server
Cclient_manager_t	Global client manager structure for server-side client coordination
Cclient_session_state_t	Client connection session state for session_client_like integration
CClientSessionBinding
Ccollect_ctx_t
Ccolor_filter_def_t	For color filter def, this is the live record that ties name, cli_name, r, g together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Ccolor_scheme_t	Color scheme definition
Ccolorscheme_palette_t
Ccompiled_color_scheme_t	Compiled ANSI escape codes for a color scheme
Ccompression_workspace_t	Owns the temporary storage used by compression workspace. The data pointers and size or cursor fields describe the live portion of the allocation; callers must use the type's cleanup path when the buffer or queue is no longer needed. Output is borrowed until the next call or destruction; never queue it without copying. The caller serializes access to the workspace
Ccompressor_t	Dynamic range compressor settings and state
Ccond_deadlock_batch_t	When code needs to work with cond deadlock entry, it keeps state here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Ccond_deadlock_entry_t
Ccond_deadlock_snapshot_t	Deadlock state is intentionally a small, concrete record. Fields such as count give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cconfig_builder_t	Helper structure for building config content in a buffer
Cconfig_option_metadata_t	Option metadata for config file parsing
Cconnection_attempt_t	Per-thread connection attempt state for parallel IPv4/IPv6 racing
Cconnection_endpoint_t
Cconsensus_coordinator	Coordinates consensus work for a session: it tracks the participant topology, election state, callbacks, and messages waiting to be processed. The session owns the coordinator and tears down its queues and synchronization objects with it
Cconsensus_handoff_message_t
Cconsensus_handoff_peer_t	Consensus handoff message is intentionally a small, concrete record. Fields such as kind, generation, sequence, upload_kbps give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cconsensus_handoff_t
Cconsensus_metrics_collection	Growable collection of participant-quality measurements. metrics, count, and capacity form the pointer/length/capacity trio; the consensus owner grows and frees the array, while readers use it only during its valid snapshot window
Cconsensus_state	State machine instance
Cconsensus_topology	Ring topology for consensus participants
Ccrypto_capabilities_packet_t	Crypto capabilities packet structure (Packet Type 14)
Ccrypto_context_t	Endpoint cryptographic state for handshake, packet protection, authentication, and rekeying
Ccrypto_handshake_context_t	Cryptographic handshake context structure
Ccrypto_parameters_packet_t	Crypto parameters packet structure (Packet Type 15)
Ccrypto_policy_t	The useful part of crypto policy is in transport_secure, encrypt, no_encrypt, no_auth: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. TLS/DTLS protect the transport. Keys request authentication, not encryption. Explicit no-encrypt wins over the password default, enabling auth-only
Ccrypto_record	When code needs to work with crypto record, it keeps crypto, key_epoch, last_receive_epoch, previous_crypto here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. The caller serializes operations and keeps the borrowed crypto context alive. One previous receive epoch survives until each channel crosses its marker
Ccrypto_rekey_session_t	Crypto rekey session is intentionally a small, concrete record. Fields such as security, send, context, activated_ns give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Ccrypto_session	For crypto session, this is the live record that ties owner, mutex, records, rotation together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Ccrypto_session_message_t
Ccustom_section_descriptor_t	Describes one non-option command-line argument and how the parser consumes it
Cdatabase_query	This is the handoff point for database query. Callers fill name, sql, access, rows before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cdatabase_session_stats_t	The useful part of database session stats is in participants, host_ready, migrating: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cdatagram_send
Cdeadlock_state_t
Cdec3_t	Decimal conversion cache structure (1-3 digits)
Cdigital_rain	Digital rain effect context
Cdigital_rain_column_t	Digital rain column keeps the values that move through the subsystem: time_offset, speed_multiplier, phase_offset. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cdiscovery_config_t	Configuration for discovery session
Cdiscovery_host_audio_capture_t	Discovery video receiver is intentionally a small, concrete record. Fields such as connection, protocol, Network Module, receiver_thread give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cdiscovery_result_t	Result from session discovery
Cdiscovery_session_t	Discovery session context
Cdiscovery_thread_state_t	Context for ACDS discovery thread
Cdiscovery_ui_state_t	This is the handoff point for discovery host audio capture. Callers fill host, Audio, participant_id, running before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cdiscovery_video_receiver_t
CDiscoveryBinding
Cducking_t	Ducking system settings and state
Celection_result_t	Election result storage
Cemit_context_t
Cendpoint_transport	This is the handoff point for acip quic endpoint. Callers fill lane, tls, udp, worker before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cenum_descriptor_t	Enum value mapping for an option
Cenum_to_string_entry_t	Enum value mapping with description for shell completions
Cenv_var_entry_t	Environment variable entry for manpage generation
Cerrno_tui_row_t
Cerrno_tui_state_t	The useful part of errno tui row is in context, resolved_ns, group_id, group_timestamp: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cerror_frame_t
Cerror_packet_t	Error packet structure carrying error code and textual description
Cerror_thread	For error thread, this is the live record that ties id, generation, top, depth together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cevent_command_t
Cevent_work_t	Event command keeps the values that move through the subsystem: fn, arg. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cevent_write
Cexample_descriptor_t	Example descriptor for programmatic EXAMPLES generation
Cface_follow_detection_t
Cface_follow_image	Face follow image is intentionally a small, concrete record. Fields such as state, last_detection, source_width, source_height give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cface_follow_rect_t	When code needs to work with face follow detection, it keeps box, confidence here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cface_follow_state_t	Face follow state keeps the values that move through the subsystem: crop, target, face, last_tick. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cffmpeg_decoder_t	FFmpeg decoder state for video and audio decoding
Cffmpeg_encoder_s	This is the handoff point for ffmpeg encoder. Callers fill codec_ctx, stream, frame, frame_encoded before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cfft_scale_t
Cfind_client_context_t	Context for finding client by participant_id
Cflow_control_debounce_t
Cfps_counter_s	Per-renderer timing state for the on-screen FPS overlay
Cfps_t	Counters and timestamps used to calculate and report frame rate
Cframe_buffer	Growable byte buffer for assembling one complete terminal frame
Cframe_queue_s
Cframe_slot_s
Cframe_t	One variable-length payload in the video ring buffer
Cframebuffer_t	Mutex-protected ring buffer used to exchange video frames
Cglobal_dec3_cache_t	Global decimal cache for digit conversion
Cglyph_cache_entry_t	Owns the temporary storage used by glyph cache entry. The data pointers and size or cursor fields describe the live portion of the allocation; callers must use the type's cleanup path when the buffer or queue is no longer needed
Cglyph_candidate_t
Cgpg_homedir	Describes a temporary GnuPG home directory used to isolate key parsing from the user's real keyring. It holds the created path and cleanup bookkeeping; callers release it through the matching helper so the directory and files are removed
Cgrep_parse_result_t	Parsed pattern result from /pattern/flags syntax
Cgrep_pattern_t	Grep pattern keeps the values that move through the subsystem: original, parsed_pattern, compiled, is_fixed_string. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Ch265_client_context
Ch265_client_decoder_t
Ch265_decoder
Ch265_encoder	H265 encoder is intentionally a small, concrete record. Fields such as codec_ctx, codec, frame, packet give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Ch265_packet_header_t
Ch265_server_context	The useful part of h265 client decoder is in client_id, decoder, last_width, last_height: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Chandler_hash_entry_t	Hash table entry for packet type to handler mapping
Chelp_mode_descriptor_t	Mode descriptor for programmatic MODES generation (for help output)
Chighpass_filter_t	Noise gate keeps the values that move through the subsystem: threshold, attack_ns, release_ns, hysteresis. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Chost_connection_t
Chost_liveness_t	When code needs to work with host liveness, it keeps last_ping_sent_ms, last_pong_received_ms, consecutive_failures, max_failures here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Chost_lost_candidate_t	Host migration state for collecting HOST_LOST packets
Chost_render_history	Owns the server-side session state, including connected participants, host callbacks, render history, and shutdown coordination. The session host creates it once, keeps it alive for the session lifetime, and releases its child resources during teardown
CHostPacketBinding
Chttp2_connection
Chttp2_header
Chttp2_request_view_t
Chttp3_receive_stream_t
Chttp3_stream_state
Chttp_basic_auth_config
Chttp_basic_credentials
Chttp_header_t
Chttp_render_frame_t
Chttp_render_options_t
Chttp_render_request_t
Chttp_render_result_t
Chttp_render_source_t
Chttp_renderer
Chttp_renderer_config_t
Chttp_renderer_job
Chttp_renderer_process_request_t
Chttp_renderer_process_result_t
Chttp_request
Chttp_request_info
Chttp_response
Chttp_server
Chttp_server_client
Chttp_server_config_t
Chttp_server_http3	For acip http3 server, this is the live record that ties http, control, request, settings_length together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Chttp_write
Cice_candidate_t	Single ICE candidate for connectivity
Cice_config_t	Credentials and callback used while gathering ICE candidates
Cimage_frame_packet_t	Describes one compressed image sent through ACIP. width, height, and pixel_format tell the decoder how to interpret the payload; compressed_size bounds the following bytes, and checksum plus timestamp support validation and frame ordering. The packet header is fixed-size, but the image bytes are variable-length and owned by the packet buffer
Cimage_source_t	One client's video input as seen by the compositor
Cimage_t	SIMD-friendly storage for one RGB pixel. r, g, and b hold the color channels and padding keeps the layout aligned for vector loads; it is normally embedded in renderer buffers, not individually allocated
CImageRGB	ImageRGB structure for NEON renderers
Cinput_editor_t
Ckeyboard_line_edit_opts_t	Options for interactive line editing
Ckeyboard_text_decoder_t
Clog_buffer_entry_t	Heap-backed message waiting for the logging output thread
Clog_format_spec_t	One literal or conversion token in a compiled log format
Clog_io_t	Saved descriptors and temporary file used during stdout/stderr capture
Clog_mmap_config	Path and size limits for the memory-mapped log file
Clog_record	Owned fields extracted from one instrumentation log line
Clog_row_ref_t
Clog_search_state_t
Clog_template_t	Compiled log format ready for use in log_template_apply()
Cloop_work_t	This is the handoff point for event work. Callers fill work, stream, run, done before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Clowpass_filter_t	This is the handoff point for highpass filter. Callers fill cutoff_hz, sample_rate, alpha, prev_input before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Clws_callback_stats_t	Callback profiling statistics for a single LWS callback reason
Cmanpage_merge_state_t
Cmanpage_resources_t	Man page resource container
Cmcp_job	When code needs to work with mcp policy, it keeps hosted, restricted, address, address6 here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cmcp_policy_t
Cmcp_server	The useful part of mcp job is in server, message, response, request: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cmdns_query_state_t	Internal state for collecting discovered services
Cmdns_refresh_t
Cmdns_snapshot_t	TUI-based server selection with formatted display
Cmdns_thread_context_t	Context for mDNS discovery thread
Cmedia_playlist_t
Cmedia_snapshot_slot
Cmedia_source_t	Media source for video and audio capture
Cmemory_backend_t	Memory backend data
CMirrorFrameBinding
Cmixer_listener_buffer	Owns the temporary storage used by mixer listener buffer. The data pointers and size or cursor fields describe the live portion of the allocation; callers must use the type's cleanup path when the buffer or queue is no longer needed
Cmixer_t	For ducking, this is the live record that ties threshold_dB, leader_margin_dB, atten_dB, attack_ns together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cmode_arguments_t	The useful part of binary actions is in show_version, create_config, create_manpage, has_action: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cmode_bit_name_t	Mode name mapping for bitmask extraction
Cmode_descriptor_t	Metadata for a mode
Cmode_metadata_t	Mode metadata for usage display
Cmode_string_mapping_t	Mode name mapping for string conversion
Cmulti_source_frame_t	One variable-length payload in the video ring buffer
Cmutex_stack_entry_t
Cmutex_wait_snapshot_t	For mutex wait snapshot, this is the live record that ties mutex_key, thread_key, since_ns, cycle together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cnamed_entry	Registry entry for uthash
Cnamed_iter_entry_t
Cnamed_metadata_cache_t
Cnamed_metadata_entry_t
Cnamed_metadata_t	The useful part of named metadata is in its fields: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cnamed_registry_t	Global registry with uthash and rwlock
Cnat_quality_t	NAT quality assessment result
Cnat_upnp_context	Handle to UPnP context
Cnative_view_t
Cnegotiate_ctx_t	Host negotiation context
Cnetwork_connect_config_t	For network connect config, this is the live record that ties timeout_ms, callback_data, tls_ca_file, quic_visual_datagrams together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record. WebSocket establishes its library-managed transport. Returns one owned object
Cnetwork_connection	Network server is intentionally a small, concrete record. Fields such as Config Module, listener, websocket, websocket_thread give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cnetwork_connection_callbacks_t	Callbacks and operations used by network connection callbacks. Packet payloads are borrowed until return. closing stops application producers; closed releases application state after the transport and callbacks have drained. An open failure still receives closing/closed, including partial application init
Cnetwork_establish_config_t
Cnetwork_establish_result_t	This is the handoff point for network establish config. Callers fill name, address, default_port, connect before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cnetwork_negotiation_t	When code needs to work with network negotiation, it keeps protocol, handshake, identity_keys, identity_key_count here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. are borrowed from server configuration until all connections have drained. The application context retains handshake storage until the closed callback
Cnetwork_server
Cnetwork_server_config_t
Cnoise_gate_t	This is the handoff point for compressor. Callers fill threshold_dB, knee_dB, ratio, attack_ns before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cnotice_snapshot_t
Copenpgp_packet_header_t	The framing fields needed to locate and classify one OpenPGP packet body
Copenpgp_public_key_t	The parsed identity portion of an OpenPGP public-key packet
Copenpgp_secret_key_t	The parsed public and private material from an OpenPGP secret-key packet
Coption_dependency_t	A rule connecting one option to another during validation
Coption_descriptor_t	The complete registry entry for one command-line/configuration option
Coption_metadata_t	Completion metadata attached to one option descriptor
Coption_parsed_value_t	Scratch storage for the scalar value produced while parsing one option
Coption_type_handler_t	Function table for extracting, validating, storing, and formatting one TOML option type
Coptions_builder_t	Immutable parsing tables produced from an options builder
Coptions_config_t	Immutable parsing tables produced from an options builder
Coptions_edit_t
Coptions_patch_result_t
Coptions_patch_t
Coptions_snapshot_t
Coptions_state	Immutable, RCU-published snapshot of the application's runtime configuration
Copus_codec_t	State for one Opus encoding or decoding direction
Copus_config_t	Opus codec parameters for ascii-chat
COpusCodecBinding
Coutbound_packet
Coutbound_stream_t
Coutbuf_t	Dynamic output buffer (auto-expanding)
Cpacket_decoder_t	When code needs to work with packet decoder, it keeps header_used, packet, used, size here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. Callback borrows a complete header+payload until it returns. It must copy any bytes it retains. An error is terminal: reset before feeding a new connection
Cpacket_envelope_t	Packet envelope containing received packet data
Cpacket_header_t	Fixed prefix shared by every ACIP packet on the wire
Cpacket_node
Cpacket_queue	For packet node, this is the live record that ties packet, next together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cpacket_queue_config_t
Cpalette_def_t	Validated luminance palette used to turn brightness into characters
Cparallel_connect_config_t
Cparsed_section_t	Owned slice of a parsed roff man-page section
Cparticipant_t	Host migration state for collecting HOST_LOST packets
Cpeer_entry_t	Webrtc peer manager is intentionally a small, concrete record. Fields such as role, Config Module, signaling, peers give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cpeer_output	Peer output is intentionally a small, concrete record. Fields such as next, data, length give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
CPeerCryptoBinding
Cpem_object_t	One decoded PEM (Privacy-Enhanced Mail) block
Cpending_ice_candidate	Hash-table record for one negotiated WebRTC participant
Cpipeline_frame_t
Cplatform_binary_match_t	Find which binary(ies) contain a given address
Cplatform_event_listener	Platform event stream is intentionally a small, concrete record. Fields such as listener, owner, tcp, timer give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cplatform_event_loop
Cplatform_event_stream	The useful part of event write is in request, stream, done, arg: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cplatform_mmap	For platform mmap, this is the live record that ties addr, size, fd together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cplatform_process_stats_t
Cplatform_signal_handler_t	Signal handler descriptor for bulk registration
Cplatform_stderr_redirect_handle_t	Handle for temporary stderr redirection
Cpositional_arg_descriptor_t	Describes one non-option command-line argument and how the parser consumes it
Cprivate_key_t	Private identity-key material used for server authentication and signing
Cprogress_snapshot_t
Cprompt_snapshot_t
Cprotocol_version_packet_t	Protocol version negotiation packet structure (Packet Type 1)
Cpublic_key_t	The normalized public identity used by ascii-chat's crypto and key-management code
Cqueued_packet_t
Cquic_config_t
Cquic_connection	This is the handoff point for receive stream. Callers fill id, received_offset, reader, active before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cquic_datagram_reader_t	Acip quic datagram slot keeps the values that move through the subsystem: data, received, cost, id. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cquic_datagram_slot_t
Cquic_endpoint
Cquic_stream_reader_t
Cquic_tls_t
Cquic_transport_t
Cquic_udp_endpoint
Cquic_worker	For acip quic worker, this is the live record that ties endpoint, lane, failure, context together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Crate_event_s	The useful part of memory backend is in events, lock: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Crate_limit_config_t	One sliding-window rate-limit policy
Crate_limiter_backend_ops_t	Backend callbacks implementing rate-limit checks, recording, cleanup, and destruction
Crate_limiter_s	Private dispatch object joining a rate-limit backend to its operations table
Creceive_context_t
Creceive_stream_t
Creceived_packet
Cregistry_entry_t	Registry entry - stores option definition with mode bitmask and metadata
Cremote_log_packet_t	Remote log packet structure carrying log level and message text
Crender_file_ctx_s	For render file ctx, this is the live record that ties progress, error, renderer, encoder together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Crender_progress	Render progress keeps the values that move through the subsystem: mutex, snapshot, fd, last_preview_ns. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Crender_worker_t
Crendered_cell_t
CRendererSessionBinding
Creport_config	Configuration for panic report generation
Crequest_state_t
Cresponse_state_t
Cretired_options	Deferred free list for old options structs
Crgb_error_t
Crgb_pixel_simd_t	Rgb pixel is intentionally a small, concrete record. Fields such as r, g, b give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Crgb_pixel_t
Cringbuffer_t	Audio ring buffer for real-time audio streaming
CRLEState	Run-length encoding state for ANSI color optimization
Cruntime_field_t
Crwlock_t	Read-write lock type (POSIX: pthread_rwlock_t with debug tracking)
Cscreen
Cscreen_snapshot_t	When code needs to work with media snapshot slot, it keeps busy, snapshot, capacity here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cscreen_terminal_t
Csdp_session_t	SDP media session (simplified for WebRTC)
Csend_chunk
Csend_stream_t
Cserver_client_removal_t
Cserver_connection_state_t
Cserver_context_t	Server context - encapsulates all server state
Cserver_discovery_policy_t	Server stats visit is intentionally a small, concrete record. Fields such as view, active, queued give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cserver_discovery_startup_t	This is the handoff point for server discovery policy. Callers fill password, has_password, has_identity, explicit_expose before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cserver_state_packet_t	Server state packet structure
Cserver_stats_t	Counters and rates describing the server's media pipeline
Cserver_stats_visit_t
Csession_audio_ctx	Session-owned audio capture, playback, and host-mixing state
Csession_audio_source_t	One participant's audio input in the host mixer
Csession_av_state_t	Generation-guarded lifecycle state for one session audio or video stream
Csession_capture_config_t	Media-source and loader settings used to create a session capture context
Csession_capture_ctx	Runtime state for media loading, frame timing, and source switching
Csession_client_like_config
Csession_connection_ops_t
Csession_connection_t	Groups the callbacks and caller data for session connection ops. The owner invokes these function pointers at lifecycle boundaries, so the referenced context must remain alive until registration is removed
Csession_consensus	When code needs to work with session consensus, it keeps topology, coordinator, send_packet, on_election here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Csession_consensus_callbacks_t	Mode-specific hooks used by the session consensus adapter
Csession_display_config_t	Terminal-rendering and snapshot settings used to create a display context
Csession_display_ctx	Runtime terminal state and reusable workspaces for ASCII rendering
Csession_entry	Persisted discovery-session record used to admit and route participants
Csession_host
Csession_host_callbacks_t	Snapshot of the address, identity, activity, and connection time for one host client
Csession_host_client_info_t	Snapshot of the address, identity, activity, and connection time for one host client
Csession_host_client_t	Keeps the host-side rendering history used to compare successive frames and stabilize output for connected participants. Its buffers and dimensions belong to the host render target and must be reset when the source or terminal geometry changes
Csession_host_config_t	Host-side event hooks for joins, departures, media, and errors
Csession_host_render_config_t	When code needs to work with session host render config, it keeps caps, palette, width, height here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Csession_host_render_target_t	Session host render target is intentionally a small, concrete record. Fields such as client_id, context give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed. Callbacks execute under the host client lock and must not call host APIs
Csession_log_buffer	Thread-safe fixed-size history ring for session-screen log lines
Csession_log_entry_t	One formatted session log line and its monotonic history sequence
Csession_participant	Client session state spanning connection, transport, media workers, and callbacks
Csession_participant_callbacks_t	Client-side event hooks for connection, media, settings, and errors
Csession_participant_config_t	Client-side event hooks for connection, media, settings, and errors
Csession_pipeline_s	For session pipeline, this is the live record that ties capture_tid, encode_tid, input_tid, input_start_status together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Csession_protocol_media_t
Csession_protocol_t	Session protocol media keeps the values that move through the subsystem: context, terminal_output, frame_workspace. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Csession_server_like_config	The useful part of session server like config is in [struct].mdns, [struct].upnp, init_fn, init_user_data: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Csession_settings_t	When code needs to work with session settings, it keeps version, width, height, color_mode here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
CSessionUiBinding
Csetting_map_entry_t	Lookup table for setting string-to-enum mapping
Csgr256_seq_t	Pre-computed 256-color ANSI SGR sequence
CSHA1_CTX
Csimd_backend_t	Simd backend keeps the values that move through the subsystem: name, required_features, luminance. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Csimd_benchmark_t	SIMD benchmark results structure
Csimd_cells_t	The useful part of simd cells is in luminance: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path. Row callbacks read/write exactly count elements. Glyph correlation reads 16 samples. Only short row tails use scalar code
Csimple_frame_swap_t	Counters and timing measurements used to monitor frame delivery and quality
Csize_packet_t	Terminal size update packet
Cspectral_config_t	For spectral config, this is the live record that ties sample_rate, fft_size, noise_gate, compressor together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cspectral_processor	Spectral processor keeps the values that move through the subsystem: config, forward, inverse, pitch_hz. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Csqlite_backend_t	This is the handoff point for sqlite backend. Callers fill db before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cssh_private_key_parse_t
Cstatic_cond_t	Static condition variable structure for global condition variables requiring static initialization
Cstatic_mutex_t	Static mutex structure for global mutexes requiring static initialization
Cstatic_rwlock_t	Statically initialized mutex wrapper for globals touched during startup. The embedded mutex carries the platform lock and initialized records whether runtime setup has completed; callers use normal mutex operations after initialization
Cstats_capabilities_t	Stats descriptor is intentionally a small, concrete record. Fields such as name, unit, description give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cstats_descriptor_t
Cstats_duration_cell_t
Cstats_duration_shard_t	For stats duration cell, this is the live record that ties sequence, observations, total_ns, min_ns together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cstats_duration_snapshot_t
Cstats_peer	When code needs to work with stats peer, it keeps scope, sampler, id here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cstats_rates_t
Cstats_sampler	This is the handoff point for stats scope. Callers fill observer, observer_context, id, started_ns before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cstats_sampler_config_t
Cstats_scope	Stats duration shard keeps the values that move through the subsystem: owner. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cstats_snapshot_t
Cstats_table_context_t
Cstats_view_t
Cstdin_buffer_reader_t
Cstdin_buffer_t
CStr	Growable NUL-terminated buffer used while assembling ASCII output
Cstream_header_t	Stream header packet structure
Csync_row_t
Csync_sample_t	Sync row keeps the values that move through the subsystem: key, owner, waiter, generation. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Ctcp_server	The useful part of tcp server is in event_loop, listen_socket, listen_socket6, running: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Ctcp_server_config_t
Ctcp_transport_data_t	Tcp transport data is intentionally a small, concrete record. Fields such as sockfd, owns_socket, is_connected, zerocopy_disabled give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cterm_renderer_config_t
Cterminal_capabilities_packet_t	Terminal capabilities packet structure (Packet Type 5)
Cterminal_capability_t	Supported terminal capability (for offer/answer)
Cterminal_fd_reader_s
Cterminal_fd_writer_s
Cterminal_format_params_t	Terminal rendering format parameters
Cterminal_renderer_s
Cterminal_screen_config_t	Configuration for terminal screen rendering
CTerminalRendererBinding
Ctest_pattern	Test pattern is intentionally a small, concrete record. Fields such as image, rgba give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
CTestPatternBinding
Ctext_snapshot_t
Cthread_entry	Hash table entry for thread-local last log record
Cthread_filter_list	Owned fields extracted from one instrumentation log line
Cthread_lock_stack_t
Cthread_pool	Thread pool structure
Cthread_pool_entry	Thread handle and shutdown metadata for one pool-owned thread
Cthread_pool_work_entry	One queued function call waiting for a thread-pool worker
Cthread_registry_entry_t	Thread lock stack keeps the values that move through the subsystem: depth, guard, telemetry. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Ctimer_record	Individual timer record for a named timing operation
Ctui_input_events_t
Cturn_credentials_t	TURN server credentials (username + password)
Cudp_peer	Acip quic udp endpoint is intentionally a small, concrete record. Fields such as socket, local, local_length, server_tls give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed
Cui_button_t
Cui_buttons_t	When code needs to work with ui button, it keeps label, shortcut, disabled, color here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cui_discovery_view_t
Cui_help_entry_t
Cui_help_menu_t	Ui help entry keeps the values that move through the subsystem: Keys Module, description. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cui_layout_t
Cui_mdns_config_t	Configuration for TUI discovery
Cui_mdns_server_t	Discovered server information from mDNS
Cui_popup_t	When code needs to work with ui popup, it keeps title, lines, line_count, footer here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cui_presentation_state_t
Cui_scrollbar_geometry_t
Cui_selectable_list_t	Ui selectable list keeps the values that move through the subsystem: selected, first_visible. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cui_session	This is the handoff point for ui session. Callers fill size, frame, media, logs before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do
Cui_session_view_t
Cui_splash_view_t
Cui_status_t	Status information for server/discovery service modes
Cui_table_column_t
Cui_table_t	The useful part of ui table column is in heading, width, alignment, ellipsis: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cui_viewport_range_t
Cui_viewport_t	For ui viewport, this is the live record that ties selected, first_visible, page_size together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cupdate_check_result_t	Update check result keeps the values that move through the subsystem: update_available, last_check_time, dismissed_until, check_succeeded. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cupdate_child_result_t
Curl_parts_t	Structure containing parsed URL components
Cusage_descriptor_t	The complete registry entry for one command-line/configuration option
Cutf8_capabilities_t	Validated luminance palette used to turn brightness into characters
Cutf8_char_info_t	UTF-8 character information structure
Cutf8_char_t
Cutf8_palette_cache
Cutf8_palette_t	When code needs to work with utf8 char info, it keeps byte_len, display_width here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cvideo_frame_buffer_t	One captured, decoded, or rendered video frame and its timing metadata
Cvideo_frame_stats_t	Counters and timing measurements used to monitor frame delivery and quality
Cvideo_frame_t	When code needs to work with simple frame swap, it keeps current_frame, frame_a, frame_b, use_frame_a here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cwav_data_header_t	Packed data chunk header giving the byte count of the following samples
Cwav_fmt_chunk_t	Packed fmt chunk describing PCM/float encoding, channels, rate, and sample width
Cwav_riff_header_t	Packed RIFF/WAVE container header written before the format and data chunks
Cwav_writer_t	File handle and sample counters needed to finalize a WAV recording
Cwaveform_color_stop_t	Waveform color stop keeps the values that move through the subsystem: frequency, red, green, blue. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself
Cwebcam_device_info_t	Webcam device information structure
Cwebcam_frame_clock_t	The useful part of webcam frame clock is in sample, previous, wall, initialized: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path
Cwebrtc_config_t	ICE, signaling, DataChannel, and callback settings for a WebRTC peer
Cwebrtc_data_channel	When code needs to work with webrtc peer connection, it keeps mapping, port_reservation, mapping_thread, mapping_stop here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields
Cwebrtc_datachannel_callbacks_t	Event hooks and caller context for one WebRTC DataChannel
Cwebrtc_peer_connection	WebRTC data channel for sending/receiving messages
Cwebrtc_peer_manager	For pending ice candidate, this is the live record that ties candidate, mid, next together. The owning code creates it, updates it while work is active, and releases its handles and pointed-to storage before freeing the record
Cwebrtc_peer_manager_config_t	Peer manager configuration
Cwebrtc_recv_msg_t	Receive queue element (variable-length message)
Cwebrtc_signaling_callbacks_t	Hooks that deliver local SDP offers/answers and ICE candidates to ACDS
Cwebrtc_transport_data_t	WebRTC transport implementation data
CWebRTCAec3Wrapper	C++ wrapper for WebRTC AEC3 (opaque to C code)
Cwebsocket_callback_stats_t	Counters and timing aggregates for one WebSocket callback kind
Cwebsocket_callback_timing_t	Timing aggregates for protocol-init, teardown, writable, and receive callbacks
Cwebsocket_client_context_t	Listener settings and callbacks used to create a WebSocket server
Cwebsocket_connection_data_t	Libwebsockets callback state for one ACIP WebSocket connection
Cwebsocket_endpoint_t
Cwebsocket_msg_t	Owned WebSocket frame queued for sending or reassembly
Cwebsocket_server	Runtime state for the WebSocket listener and its client-handler pool
Cwebsocket_server_config_t	Listener settings and callbacks used to create a WebSocket server
Cwebsocket_transport_data_t	Private state for one libwebsockets-backed ACIP transport
Cword_cache_entry_t	One owned word in the adjective or noun validation hash table
Cyt_dlp_cache_entry_t	Cached yt-dlp result for one media source and its audio/video requests
Cyt_dlp_request_options_t