| Npulp | |
| Naudio | |
| Nbuffer_ops | |
| CMinMax | Pair returned by find_min_max |
| CPeakRms | Block level reading returned by measure_peak_rms: the peak absolute sample value and the root-mean-square level |
| Ndetail | |
| CSampleMemoryGovernorState | |
| CAnalyzerDescriptor | |
| CAnalyzerSelectionPolicy | |
| CPackageAnalyzerDescriptorInput | |
| CAnalyzerProvenance | |
| CAnalyzerMarkerProvenance | |
| CKeyTempoAnalysisConfig | |
| CKeyTempoAnalysisResult | |
| CTransientClassification | |
| CTimePitchPrepareConfig | |
| CTimePitchProcessSpec | |
| CTimePitchPrepareResult | |
| CTimePitchProcessResult | |
| CKeyTempoAnalyzer | |
| CTransientClassifier | |
| CTimePitchProcessor | |
| CAnalyzerProviderRegistry | |
| CAsyncBlockEvent | A timed event handed to or produced by the worker |
| CAsyncBlockWorkerConfig | |
| CAsyncBlockWorkerStats | |
| CAsyncBlockWorker | Plays audio that a worker thread renders, at an exact, fixed latency, for a host whose blocks vary in size |
| CChunk | One stretch of positions the job renders |
| CDeviceStatsView | Device-side facts the report mirrors (owned by AudioDeviceManager / the CoreAudio overload listener — never by the probe) |
| CBoundaryReport | |
| CBoundaryReportInputs | Inputs to the report |
| CDeviceSelection | Persisted audio-device selection |
| CMidiSubscriptionToken | RAII subscription token |
| CAudioDeviceManager | AudioDeviceManager — persistence + MIDI hub |
| CResolveResult | Resolve a stored selection against the live device list |
| CRuntimeTelemetrySnapshot | Manager-owned runtime telemetry that combines callback load and backend xrun/overload counters for live tools |
| CDeviceChangeEvent | |
| CDeviceChangeToken | RAII subscription token for device-change events |
| CMidiEndpoint | |
| CMidiEndpointChange | |
| CAudioFileInfo | |
| CAudioFileData | |
| CAudioFocusRegistry | |
| CToken | RAII subscription token. Move-only; destruction unsubscribes |
| CAudioIoTiming | Immutable control-thread snapshot of one audio route's I/O timing |
| CLatencySnapshot | Control-thread composition of backend I/O timing with the graph's already computed total latency |
| CAudioProbeCaptureConfig | Configuration for the optional last-N-frames capture ring |
| CAudioProbe | Realtime output-boundary probe |
| CAudioProbeSnapshot | Realtime-produced, fixed-capacity, trivially-copyable probe summary |
| CAudioScopeAcquisitionConfig | |
| CAudioScopeAcquisition | |
| CAudioScopeMeasurements | |
| CAudioScopeResult | |
| CAudioStats | Minimal release-safe audio counter aggregate |
| CAudioStreamHandoffConfig | |
| CAudioStreamHandoffPullResult | |
| CAudioStreamHandoffStats | |
| CAudioStreamHandoff | |
| CAudioTap | Fixed-capacity, single-producer/single-consumer audio analysis tap |
| CBufferView | Non-owning view over multi-channel audio sample data |
| CBuffer | Owning multi-channel audio buffer with contiguous storage |
| CBufferingReader | Background-thread audio file reader for gapless streaming playback |
| CBuiltInKeyTempoAnalyzer | |
| CBuiltInTransientClassifier | |
| CChannelSet | Named channel layout — maps channel indices to speaker positions |
| CDeviceInfo | |
| CDeviceConfig | |
| CCallbackContext | |
| CAudioDevice | |
| CAudioSystem | |
| CExcerptQuery | |
| CExcerptWindow | |
| CExcerptCandidate | |
| CExcerptSearchSummary | |
| CFiniteTimeStretchConfig | |
| CFiniteTimeStretchJob | Control-thread-only, bounded finite SRC + time-stretch job |
| CAudioFormatReaderSource | Plays back a MemoryMappedAudioReader as a PositionableAudioSource |
| CDecodeLimits | Resource ceilings a reader enforces on decoded output |
| CFormatReader | Audio format reader interface |
| CFormatWriter | Audio format writer interface |
| CFormatRegistry | Registry of audio format readers and writers |
| CImpulseResponseLoadOptions | |
| CAhdsrEnvelopeConfig | |
| CAhdsrEnvelope | |
| CInstrumentTriggerResult | |
| CInstrumentRuntime | |
| CInstrumentVoice | |
| CVoiceTermination | |
| CInstrumentVoiceTrigger | |
| CVoiceAllocationResult | |
| CInstrumentVoiceAllocator | |
| CLiveDspNodeInfo | Immutable per-node identity, supplied to prepare() and copied into the store |
| CLiveDspTelemetryConfig | |
| CLiveDspSpectralDiagnostic | |
| CLiveDspNodeSummary | Per-node rolling summary produced by drain() |
| CLiveDspTelemetrySnapshot | Latest published summary. Owned by the store; valid until the next drain() |
| CLiveDspTelemetryNodeScope | RAII per-node timing scope, constructed inside begin_block()'s active block |
| CLiveDspTelemetryBlockWriter | Handle for one audio block |
| CLiveDspTelemetryStore | The store. One producer (audio thread) and one consumer (drain/owner thread) |
| CAudioProcessLoadSnapshot | Snapshot published by AudioProcessLoadMeasurer |
| CAudioRuntimeOverloadPolicy | |
| CAudioRuntimeOverloadReport | |
| CLoadClockRatio | Converts a span of monotonic clock ticks to nanoseconds |
| CAudioProcessLoadMeasurer | Measures the CPU load of an audio processing callback |
| CLoopFrameReadPlan | |
| CLoopPlaybackAdvanceResult | |
| CLoopPlaybackCursor | Allocation-free loop traversal state independent of sample storage |
| CLoopPointAnalysisConfig | |
| CLoopPointCandidate | |
| CLoopEndpointSnapResult | |
| CLoopPointAnalysisResult | |
| CLoopPointAnalyzer | |
| CLoopReader | |
| CLoopRenderResult | |
| CLoopRenderer | |
| CLoopRegion | |
| CLoopValidationResult | |
| CMidiVoiceModulationState | |
| CMidiVoiceModulationAdapter | |
| CMemoryMappedAudioReader | Memory-mapped audio file reader |
| COfflineRenderBlockContext | Per-block metadata for deterministic offline renders |
| COfflineRenderComputePolicy | |
| COfflineRenderComputeDecision | |
| COfflineRenderResourceRef | |
| COfflineRenderOptions | Advanced offline render options |
| COfflineRenderStem | |
| COfflineRenderedStem | |
| COfflineRenderStemResult | |
| COfflineRenderComparison | |
| COfflineRenderManifestChunk | |
| COfflineRenderArtifactManifest | |
| COnsetDetectionConfig | |
| COnsetMarker | |
| COnsetDetectionResult | |
| COnsetDetector | |
| CPcmCapabilities | What one direction (playback or capture) of a device can do |
| CPcmDeviceSummary | The lists and channel counts a DeviceInfo carries for one device |
| CPlanarAudioRingBufferStats | |
| CPlanarAudioRingBuffer | |
| CPublishedSampleStoreConfig | |
| CPublishedSampleStore | |
| CPullRateDetector | Detects a host that calls the audio callback faster than real time |
| CRealtimeSampleRecorderTiming | |
| CRealtimeSampleRecorderCommand | |
| CRealtimeSampleRecorderEvent | |
| CRealtimeSampleRecorderConfig | |
| CRealtimeSampleRecorderStats | |
| CRealtimeSampleRecorder | |
| CRealtimeTimeStretchStreamFinalizePlan | |
| CRealtimeTimeStretchConfig | |
| CRealtimeTimeStretchPreparedGeometry | |
| CRealtimeTimeStretchProcessor | Move-only prepared stream |
| CRollingAudioCaptureBufferConfig | |
| CRollingAudioCapturePrepareResult | |
| CRollingAudioCaptureSnapshot | |
| CRollingAudioCaptureMaterializeResult | |
| CRollingAudioCaptureHold | |
| CRollingAudioCaptureBuffer | |
| CRtSafetyContract | |
| CSampleAssetToken | |
| CSampleAssetConfig | |
| CSampleAssetRegistrationProof | |
| CSampleAssetView | Immutable audio-thread snapshot borrowed from one SampleAsset owner |
| CSampleAsset | Off-audio-thread owner for immutable sampler metadata and resident preload |
| CSampleAssetPolicy | |
| CSampleAssetDescriptor | |
| CSampleAssetImportResult | |
| CSampleAssetExportResult | |
| CSampleAssetDropItem | |
| CSampleAssetImporter | |
| CSampleAssetExporter | |
| CSampleBankSample | |
| CSampleBankZone | |
| CSampleBankManifest | |
| CSampleBankParseResult | |
| CSampleBankWriteResult | |
| CSampleBankContentIssue | |
| CSampleBankContentValidationResult | |
| CSampleBankMaterializePolicy | |
| CPreparedSampleBank | |
| CSampleBankMaterializeResult | |
| CSampleBankMaterializer | Control/background-thread loader |
| CSampleConverter | Run-time PCM converter |
| CEditableSampleSource | |
| CEditableSampleState | |
| CSampleEditOperation | |
| CEditableSampleDocument | |
| CSampleEditHistory | |
| CSampleHeritageBusDsp | Stateful post-mix processor for typed heritage bus blocks |
| CSampleHeritagePrepareConfig | |
| CSampleHeritageProcessPlan | |
| CSampleHeritageEngine | |
| CSampleHeritageJsonParseResult | |
| CSampleHeritageJsonWriteResult | |
| CSampleHeritageRuntimeStateJsonParseResult | |
| CSampleHeritageRuntimeStateJsonWriteResult | |
| CSampleHeritageTypedRuntimeStateJsonParseResult | |
| CSampleHeritageTypedRuntimeStateJsonWriteResult | |
| CSampleHeritageLiveCyclicConfig | |
| CSampleHeritageLiveCyclicResources | |
| CSampleHeritageLiveCyclicPlan | |
| CSampleHeritageLiveCyclicRngContinuation | |
| CSampleHeritageLiveCyclicStretch | Fixed-capacity cyclic resynthesis for realtime sample playback |
| CSampleHeritagePitchPlan | |
| CSampleHeritagePitchProcessor | Streaming pitch-family mechanism for one sampler voice |
| CSampleHeritageAutoCycleOptions | |
| CSampleHeritageAutoCycleResult | |
| CSampleHeritageRecordProvenance | |
| CSampleHeritageCommittedAssetMetadata | |
| CSampleHeritageCommittedAsset | Immutable result of the allocating, off-audio-thread record-commit path |
| CSampleHeritageRecordCommitResult | |
| CSampleHeritageRuntimeRngState | |
| CSampleHeritageRuntimeState | Fixed-capacity continuation payload for seeded stages |
| CSampleHeritageRuntimeEngineState | |
| CSampleHeritageVoiceRuntimeState | |
| CSampleHeritageTypedRuntimeState | Fixed-capacity continuation envelope for the typed sampler topology |
| CSampleHeritageRuntimeStateCapture | |
| CSampleHeritageTypedRuntimeStateCapture | |
| CSampleHeritageVoiceMachineDomainBlock | |
| CSampleHeritageVoiceClockBlock | |
| CSampleHeritageVoicePitchBlock | |
| CSampleHeritageVoiceConverterBlock | |
| CSampleHeritageVoiceHoldDroopBlock | |
| CSampleHeritageVoiceReconstructionBlock | |
| CSampleHeritageVoiceAnalogColorBlock | |
| CSampleHeritageVoiceLiveCyclicStretchBlock | |
| CSampleHeritageVoiceBlockSpec | |
| CSampleHeritageBusNoiseIdleBlock | |
| CSampleHeritageBusOutputDriveBlock | |
| CSampleHeritageBusBlockSpec | |
| CSampleHeritageRecordInputDriveClipBlock | |
| CSampleHeritageRecordRateBlock | |
| CSampleHeritageRecordConverterBlock | |
| CSampleHeritageRecordCommitCyclicStretchBlock | |
| CSampleHeritageRecordCommitAdaptiveStretchBlock | |
| CSampleHeritageRecordCommitBlockSpec | |
| CSampleHeritageMachineDomainStage | |
| CSampleHeritageQuantizationStage | |
| CSampleHeritageClockPitchStage | |
| CSampleHeritageDacHoldStage | |
| CSampleHeritageReconstructionFilterStage | |
| CSampleHeritageNoiseStage | |
| CSampleHeritageOutputStage | |
| CSampleHeritageStageSpec | |
| CSampleHeritageProfile | Authoring/serialization schema |
| CSampleHeritagePreparedProfile | |
| CSampleHeritageProfileValidation | |
| CSampleHeritageSrcPlan | |
| CSampleHeritageCausalSrc | Bounded causal streaming sample-rate converter for the heritage pipeline |
| CSampleHeritageVoiceDsp | Prepared, fixed-memory processor for the typed per-voice heritage blocks |
| CSampleInterpolationPolicyInfo | Stable serialization/UI metadata for one interpolation policy |
| CSampleInterpolationFootprint | |
| CPreparedSampleInterpolation | |
| CResolvedSampleInterpolationPosition | |
| CSampleKeyMapConfig | |
| CSampleKeySliceResolution | |
| CSampleKeyMap | |
| CSampleMemoryGovernorEpoch | |
| CSampleMemoryGovernorStats | |
| CSampleMemoryLease | Move-only reservation against one shared sampler-memory cap |
| CSampleMemoryReserveResult | |
| CSampleMemoryGovernorHandle | Copyable lifetime-safe reservation/stats endpoint |
| CSampleMemoryGovernor | Shared off-audio-thread admission governor for resident preload heads and stream-cache pages |
| CSampleMipSidecar | |
| CLevel | |
| CSampleMipBuildOptions | |
| CSampleMipBuildResult | |
| CSamplePoolEntry | |
| CSamplePoolResolution | |
| CSamplePool | |
| CSamplePreloadContract | |
| CSamplePreloadContractResult | |
| CPreparedSampleRateConversion | Immutable, allocation-free read kernel after control-thread construction |
| CSampleRateConversionBuilder | |
| CVariableRateConversionBuilder | |
| CPreparedVariableRateConversion | |
| CSampleResourceSnapshot | |
| CSampleResourceDiagnostics | |
| CSampleResourceHandle | |
| CSampleResourceCacheLimits | |
| CSampleResourceCacheStats | |
| CSampleResourceCache | Control-thread decoded sample cache for samplers and loopers |
| CSampleResourcePage | |
| CSampleResourcePageWindow | |
| CSampleResourcePageHandoffDiagnostics | |
| CSampleResourcePageHandoff | Render-thread view of immutable decoded sample pages |
| CSampleResourceLoadOptions | |
| CSampleResourceServiceStats | |
| CSampleResourceService | Non-RT service for background sample decode and cache prefetch |
| CSampleSincKernelConfig | |
| CSampleSincKernelView | |
| CSampleSincKernel | |
| CSampleSincKernelSelection | |
| CSampleSincKernelBankView | |
| CSampleSincKernelBank | |
| CPublishedSampleView | |
| CSampleSlotBank | |
| CSampleStarvationEnvelopeConfig | |
| CSampleStarvationEnvelopeStats | |
| CSampleStarvationEnvelope | |
| CSampleStreamAsyncServiceConfig | |
| CSampleStreamAsyncPrepareResult | |
| CSampleStreamAsyncDispatchResult | |
| CSampleStreamAsyncServiceTelemetry | |
| CSampleStreamAsyncNoopDispatchCutpoint | |
| CSampleStreamAsyncService | Owner-thread integration for cache reservations and background decode workers |
| CSampleStreamConsumptionFactors | |
| CSampleStreamConsumptionEvaluation | |
| CSampleStreamConsumptionDeclaration | |
| CSampleStreamDecodePoolConfig | |
| CSampleStreamDecodeJob | |
| CSampleStreamDecodeCompletion | |
| CSampleStreamDecodeSourceAddResult | |
| CSampleStreamDecodePoolTelemetry | |
| CSampleStreamDecodeCompletionView | |
| CSampleStreamDecodePool | Fixed-storage owner/worker decode pool |
| CSampleStreamLoopBlockPlan | |
| CSampleStreamLoopVoiceReader | Allocation-free paged adapter for LoopPlaybackCursor |
| CSampleStreamPageRequest | |
| CSampleStreamSchedulerStats | |
| CSampleStreamRequestInbox | |
| CSampleStreamScheduler | Single-owner background scheduler for shared sample-cache page fills |
| CSampleStreamSourceToken | |
| CSampleStreamRequesterToken | |
| CSampleStreamCacheServiceConfig | |
| CSampleStreamCacheSourceConfig | |
| CSampleStreamPageDemand | |
| CSampleStreamCommand | |
| CSampleStreamCommandInboxTelemetry | |
| CSampleStreamCommandInbox | Prepared bounded command port from one RT producer to the service owner |
| CSampleStreamCommandDrainResult | |
| CSampleStreamSourceRegistrationProof | |
| CSampleStreamCacheSourceView | |
| CSampleStreamSourceAddResult | |
| CSampleStreamAsyncReservation | |
| CSampleStreamAsyncReserveResult | |
| CSampleStreamCacheServiceStats | |
| CSampleStreamCacheService | Bounded shared-page cache with deterministic caller-driven servicing |
| CSampleStreamVoiceBlockPlan | |
| CSampleStreamVoiceBlockResult | |
| CSampleStreamVoiceDemandEnqueueResult | |
| CSampleStreamVoiceReader | Allocation-free linear forward one-shot reader over immutable sample assets |
| CSampleStreamWindowConfig | |
| CSampleStreamPageDescriptor | |
| CSampleStreamPageView | |
| CSampleStreamWindowReadRequest | |
| CSampleStreamWindowReadResult | |
| CSampleStreamWindowStats | |
| CSampleStreamWindow | |
| CSampleVoiceRenderState | |
| CSampleVoiceRenderOptions | |
| CSampleVoiceRenderResult | |
| CSampleVoiceRenderer | |
| CSampleZone | |
| CZoneSelectionRequest | |
| CZoneSelection | |
| CSampleZoneMap | |
| CZoneSelector | |
| CSamplerLooperMetricsSnapshot | |
| CSignalsmithTimePitchProcessor | |
| CSliceMarker | |
| CSliceRegion | |
| CSliceMap | |
| CSliceMarkerClassification | |
| CSlicePointAnalysisConfig | |
| CSlicePointAnalysisResult | |
| CSliceSelectionOptions | |
| CSlicePointAnalyzer | |
| CAudioSource | Abstract base — host-callable audio source |
| CPositionableAudioSource | AudioSource with a notion of position |
| CAudioSourcePlayer | Drives an AudioSource from a host audio callback |
| CFrameReaderStopToken | Cooperative cancellation signal passed to a streaming frame reader |
| CFrameReaderBinding | |
| CStreamingSampleSourceConfig | |
| CStreamingSampleSource | |
| CStats | |
| CFileFrameReader | A FrameReader plus the opened file's properties, ready to feed into a StreamingSampleSourceConfig (channels / total_frames / sample_rate) |
| CStreamingWriter | Streaming audio writer — writes audio in chunks to a file |
| CAudioSubsectionReader | A view into a sub-range of an AudioFileData |
| CAudioTransportSource | Wraps a PositionableAudioSource with transport-level control: |
| CUnisonVoiceStackTrigger | |
| CUnisonVoiceChild | |
| CUnisonVoiceTermination | |
| CUnisonVoiceStackResult | |
| CUnisonVoiceStackTerminationResult | |
| CUnisonVoiceStackManager | |
| CVoiceModulationResult | |
| CVoiceModulationAudioRateReservation | |
| CVoiceModulationBufferConfig | |
| CVoiceModulationLane | |
| CVoiceModulationBlock | |
| CVoiceModulationBuffer | |
| CVoiceLfoSourceSpec | |
| CVoiceEnvelopeSourceSpec | |
| CVoiceModulationSourcesConfig | |
| CVoiceModulationSources | A fixed-capacity bank of per-voice modulation sources |
| CVoiceNoteModulationResult | |
| CVoiceNoteModulationInput | Note/controller state translated to constant per-voice modulation lanes |
| CVoiceNoteModulationRouting | Explicit mapping from note semantics to VoiceModulationBuffer targets |
| CVoiceNoteModulationBridge | |
| CAllocatedVoiceRuntimeTriggerResult | |
| CVoiceRuntimeFacade | Primary template intentionally rejects unsupported owners |
| CVoiceRuntimeFacade< midi::Synthesiser< Voice > > | Plain-MIDI facade |
| CVoiceRuntimeFacade< InstrumentVoiceAllocator > | Prepared slot facade |
| CVoiceSumInput | |
| CVoiceSumOptions | |
| CVoiceSumResult | |
| CVoiceSumMixer | |
| CWavDecodeLimits | Resource ceilings checked before the decoder allocates output storage |
| CBwavMetadata | |
| CAcidMetadata | |
| CWavMetadata | |
| CUnknownChunk | |
| CAudioPeak | |
| COverviewLevel | |
| CWaveformOverviewInfo | |
| CWaveformOverview | |
| CWaveformOverviewCacheStats | |
| CWaveformOverviewCache | |
| CWavetableCycleSelection | |
| CWavetableAuthoringRecipe | |
| CWavetableAuthoringProvenance | |
| CWavetableCompileResult | |
| CWindowEnumerationResult | |
| CAudioWorkgroup | Manages real-time thread priority for audio processing threads |
| Nstate | SequencerStateChannel is the audio-safe transport for a plugin's structured NON-parameter state: the bulk, observable state a step sequencer / mod-matrix / pattern engine holds outside its automatable parameter set (e.g |
| CContentInstallLimits | Caps on what an archive may inflate to |
| CContentSizeBudget | Running admission of archive entries against a ContentInstallLimits |
| CContentPackInfo | Metadata for one installed content pack |
| CContentInstallPolicy | |
| CContentInstallPreview | |
| CContentInstallResult | |
| CContentRegistry | Installed content lookup |
| CBinding | Reactive binding between a UI widget and a StateStore parameter |
| CCachedProperty | Cached accessor for a StateTree property |
| CContentCapabilityManifest | Capabilities a plugin declares before consuming installed content packs |
| CEditAction | Base class for undoable actions |
| CLambdaEdit | Convenience action using lambdas |
| CEditHistory | Global undo/redo history for the application |
| CExternalBindingConfig | Configuration for an ExternalBinding: the getter/setter that back a UI control whose value is NOT a StateStore parameter — e.g |
| CExternalBinding | Reactive binding between a UI widget and an arbitrary external value source, interface-compatible with state::Binding but backed by getter/setter lambdas instead of a StateStore parameter |
| CListenerToken | RAII handle for a registered parameter-change listener |
| CMidiMapScale | Normalized [0, 1] output window a CC sweep is mapped onto |
| CMidiParameterMap | |
| CModulationSource | |
| CModulationTarget | |
| CModulationLane | |
| CModulationLaneValidation | |
| CParamSnapshotEntry | |
| CParamCursor | |
| CParamOrderingViolation | One way a new descriptor version broke a previously-shipped parameter's host-facing identity |
| CBaseOffsetValue | Canonical automation value shared by graph, Processor, and timeline delivery |
| CParamRange | Defines the numeric range of a parameter, including normalization |
| CSkewedRange | Skew-aware normalized range with optional symmetric center |
| CParamInfo | Immutable parameter metadata, registered once at plugin initialization |
| CParamValue | Thread-safe atomic parameter value for lock-free audio/UI communication |
| CParameterEdit | |
| CParameterEvent | |
| CModulationEvent | Timestamped host modulation event |
| CModulationEventQueue | |
| CParameterEventQueueTelemetry | |
| CParameterEventQueue | |
| CPresetInfo | Metadata for a single preset file |
| CParamSetting | One parameter value read from a preset file |
| CPresetManager | Built-in preset manager for Pulp plugins |
| CPropertiesFile | JSON-backed persistent settings file |
| CApplicationProperties | Application-level properties with platform-standard paths |
| CStepCell | One step in one lane |
| CPlayheadState | Volatile, high-rate transport/playhead state |
| CSequencerConfig | Lanes/Steps/Patterns are MAXIMUM CAPACITY (active extent lives in the Snapshot) |
| CDirtyRegion | |
| CSetCellEditT | SetCell carries a full cell by value, so it is templated on the Config's cell type |
| CClearEdit | |
| CRandomizeLaneEdit | |
| CSetPatternLengthEdit | |
| CSwitchPatternEdit | |
| CStepEditCommandT | |
| CPayload | |
| CPatternStateT | |
| CSnapshotT | The full non-param state, published for bulk replacement / resync only |
| CStepRangeAppliedT | The exact cells the engine wrote for a step-range edit |
| CAppliedEditT | |
| CPayload | |
| CSequencerStateChannelT | Ownership: the engine (audio) thread is the single reader of the command queue and the single writer of the applied queue / snapshot / playhead |
| CStateMigrationRegistry | Offline migration support for serialized StateStore payloads |
| CPropertyArrayValue | |
| CPropertyObjectValue | |
| CPropertyArray | |
| CPropertyObject | |
| CTreeEditError | Error value for a refused StateTree edit |
| CStateTree | Reactive tree node — each node has a type name, properties, and children |
| CTransaction | RAII transaction on a StateTree |
| CValidatedTransaction | A transaction whose edits are checked and return TreeEditResult instead of being silently ignored |
| CSyncedClone | Owns the listener wiring created by StateTree::clone_synced() |
| CObservableValue | Observable value — wraps a single value with change notification |
| CSyncDelta | A single change to synchronize |
| CStateTreeSynchroniser | Encodes StateTree changes as deltas for transmission |
| CParamGroup | Named parameter group for hierarchical UI organization |
| CRtListenerQueueTelemetry | Snapshot of StateStore's real-time listener queue |
| CParameterGestureApplyResult | |
| CParameterFeedbackBaseline | Opaque exact identity captured when asynchronous work is ordered against a parameter |
| CConditionalParameterApplyResult | |
| CParamReader | Pre-resolved audio-thread read handle for one parameter's base value |
| CStateStore | Centralized parameter storage with lock-free value access |
| CParamWrite | One parameter write in a set_values_rt() batch |
| CModulationWatchers | |
| CEntry | |
| CModulationWatch | RAII handle for watch_modulation(). Move-only; dropping it unwatches |
| CUndoAction | A single undoable action with undo and redo functions |
| CUndoTransaction | A group of actions that undo/redo together as one step |
| CUndoManager | Manages undo/redo history with configurable depth |
| Nauthoring_capsule | |
| CMemberInfo | |
| CCapsuleArchive | A reader over an admitted archive |
| CWriteMember | One member to write. path must already be normalized |
| CCanonicalPcm | |
| CAdmissionOptions | |
| CExportItem | One member of an export inventory |
| CExportRequest | |
| CRedistribution | Permission to pass a component's bytes on |
| CComponentPolicy | |
| CFileEntry | One row of the archive closure |
| CDependencyEntry | A component whose bytes are not in the archive |
| CComponentRef | A reference to one component row, for a result that must name components it does not own |
| CCapsuleLimits | |
| CCompatibility | Version floors the consuming runtime must satisfy |
| CManifest | |
| CCapabilityRequirement | |
| CDependencySummary | |
| CRightsSummary | Rights facts, machine-derived |
| CCapsulePreview | |
| CProfileValidator | Semantic validation of an extracted staging tree |
| CProfileRegistry | |
| CSignatureEnvelope | |
| CVersionFloor | Minimum version the signer will let this capsule be admitted at |
| CSignatureVerifier | |
| CStagingArea | A private directory that is removed when it goes out of scope unless it was published |
| CCapsuleError | A rejection with the exact subject that caused it |
| Ncanvas | |
| Ndetail | |
| CUtf8ScalarForOffsets | |
| CPoint2D | A 2D point |
| CAffineTransform | |
| CTextSpan | A span of text with consistent styling |
| CAttributedString | Attributed string — a sequence of styled text spans |
| CTextLayoutLine | Multi-line text layout result |
| CTextLayout | |
| CBidiRun | One contiguous span of text that shares a single bidi embedding level |
| CBidiParagraph | Aggregate paragraph-level bidi result |
| CBidiAnalyzer | |
| CDeclaredWeightRange | One CSS @font-face rule's declared font-weight range (a single weight has min == max) |
| CColor | |
| CHSV | |
| CHSL | |
| COKLCH | |
| CGradientStop | |
| CLinearGradient | |
| CRadialGradient | |
| CConicGradient | Conic (sweep) gradient — colors sweep around a center point |
| CFillStyle | Unified fill style — solid color, linear, radial, or conic gradient |
| CCanvas | |
| CAffineTransform2x3 | Affine 2x3 transform snapshot, six floats laid out as CanvasRenderingContext2D.setTransform / DOMMatrix: [ a c e ] [ b d f ] [ 0 0 1 ] Identity is {1, 0, 0, 1, 0, 0} |
| CLayerHandle | An opaque reference to a compositing layer owned by the canvas |
| CFilterChainEntry | Full CSS filter-chain layer save |
| CFontFeature | |
| CTextMetrics | Full text metrics for layout and intrinsic sizing |
| CSDFStyle | |
| CWaveformStyle | Draw a waveform using GPU shader (SDF anti-aliased line + fill) |
| CShaderUniforms | Uniforms passed to custom widget shaders |
| CNamedUniform | An arbitrary named shader uniform (name → float / vec2 / vec3 / vec4) |
| CShaderDataTexture | Latest-wins audio/vector payload exposed to an SkSL child shader |
| CShaderGeometry | |
| CShaderDrawOptions | |
| CFitResult | Placement rectangle produced by fit_image_rect |
| CCoreGraphicsCanvas | |
| CFontRun | |
| CFallbackTraceRecord | One resolution event |
| CFontFlightRecorder | |
| CFontFeature | OpenType feature record: tag + value |
| CVariationAxis | |
| CFontSynthesisPolicy | Explicit policy for faux-bold / faux-italic / faux-width |
| CFontScopeId | Opaque identifier for a FontScope (defined in font_scope.hpp) |
| CFontOptions | The typed, hashable contract that replaces (family_string, size) throughout the font subsystem |
| CCssFontFamily | One entry of a CSS font-family list, as written |
| CFallbackTraceStep | |
| CSynthesisTrace | |
| CResolvedFont | |
| CFontResolver | |
| CFontScope | |
| CGradientInterpolation | |
| CDecodedRaster | A decoded raster image |
| CGifFrame | |
| CGifReader | GIF reader. Decodes GIF87a + GIF89a streams |
| CGifWriter | GIF writer |
| CTiffReader | TIFF reader |
| CTiffWriter | TIFF writer |
| CImageConvolutionKernel | NxN convolution kernel for image processing |
| CLottieAnimation | |
| CMsdfGlyph | |
| CMsdfAtlas | |
| CStrokeStyle | Everything needed to stroke a path, as one value |
| CPath | |
| CElement | One step of an iteration over the path |
| CIterator | Forward iterator over the verbs |
| CFlatSubpath | Flatten every curve to line segments, within tolerance user units of the true curve |
| CPathPose | A position on a measured path, with the direction of travel there |
| CPathMeasure | |
| CPsdfAtlas | |
| CDrawCommand | |
| CRecordingCanvas | |
| CRect2D | Axis-aligned rectangle in canvas coordinates |
| CRectangleList | List of non-overlapping rectangles — used for clip regions and dirty tracking |
| CResourceCounters | |
| CVectorScene | |
| CSceneGroup | |
| CSceneImage | |
| CSceneRect | Axis-aligned bounding box used for repaint-rect math |
| CSceneTransform | 2D affine transform (CanvasRenderingContext2D layout): [ a c e ] [ b d f ] [ 0 0 1 ] |
| CSceneNode | Abstract base of every node in a VectorScene |
| CScenePath | |
| CSceneShape | |
| CSceneText | |
| CSceneRecording | Opaque handle to a subtree's recorded draw commands, produced by Canvas::record_scene() and replayed by Canvas::draw_scene() |
| CSdfGlyph | |
| CSdfAtlas | |
| CCachedGlyph | |
| CSdfAtlasCache | |
| CSdfEffectParams | |
| CSdfTextOptions | |
| CSdfTextQuad | |
| CRunMetrics | Per-line / per-run typographic metrics |
| CShapedRun | One run inside a ShapedText — a maximal slice of the input text that shares (bidi level × script × language × resolved typeface × applied features × applied variation axes) |
| CClusterEntry | One grapheme cluster in the input |
| CLineBreakOpportunity | Line-break opportunity used by the line layout step |
| CUnicodeIndexMap | JS counts UTF-16, ICU APIs vary between UTF-16 and scalar offsets, HarfBuzz reports cluster indices, accessibility APIs vary by platform, and Pulp's internal storage is UTF-8 |
| CShapedText | The canonical output of TextRunPlanner::shape(text, FontOptions) |
| CSvgImage | |
| CFontSpec | Font style specification for text layout |
| CTextRun | A run of text with uniform style within a paragraph |
| CGlyphPosition | Result of laying out a line of text — position and metrics for each glyph |
| CTextLine | A single line of laid-out text |
| CGlyphArrangement | Glyph arrangement — the result of text layout, containing positioned glyphs for each line |
| CParallelogram | Parallelogram — a skewed rectangle defined by base point and two edge vectors |
| CTextRasterTuple | Surface text contrast and gamma for a policy, the two values SkSurfaceProps carries |
| CTextRunPlanner | |
| CShapedSegment | A measured text segment — cached after shaping |
| CPreparedText | Prepared text — shaped once, can be reflowed at any width |
| CShapedLayout | Result of laying out prepared text at a specific width |
| CLine | |
| CFragment | |
| CTextShaper | Text shaper — the PreText-style measure-once-reflow-forever engine |
| CParagraphLineExtent | One shaped paragraph line's own vertical metrics, as SkParagraph's LineMetrics reports them |
| CParagraphTextExtents | Worst-case vertical extents over every line of a shaped paragraph |
| CViewEffect | Base class for GPU post-processing effects |
| CGpuBlurEffect | GPU blur effect — multi-pass Gaussian blur via SkImageFilters |
| CGpuBloomEffect | GPU bloom/glow — a real bright-pass + blur + additive composite |
| CChromaticAberrationEffect | Chromatic aberration — real per-channel RGB offset for a glitch/lens effect |
| CVignetteEffect | Vignette — darken the edges of the view by drawing a real radial-gradient overlay on top of the finished content: transparent at the center, fading to edge_color (scaled by intensity) at the corners |
| CSkslPostEffect | Arbitrary-SkSL view post-effect |
| CEffectChain | Chains multiple effects in sequence |
| Ndataplane | |
| Ndetail | |
| CPublishedValue | |
| CMeterData | |
| CMeterBallistics | |
| CAudioBridge | |
| CStateStoreHostParamSurface | The native (Pulp Processor::create_view()) backing for HostParamSurface, implemented over a StateStore |
| CHostParamSurface | A framework-agnostic, native-view-facing runtime parameter accessor |
| CHostActionSurface | A framework-agnostic host command channel |
| CValueChannelSet | A processor's declared channels |
| CValueChannelInfo | What a channel is, for discovery and for a UI lint to check names against |
| CValueChannelTelemetrySnapshot | A coherent continuous payload copied by the existing UI reader path |
| CValueChannelTelemetryEventBatch | One producer event batch retained by the ordered telemetry tap |
| CValueChannelTelemetryEventStats | Current producer-tap state. Overflow is cumulative for the source lifetime |
| CValueChannelTelemetryDescriptor | Stable metadata for a channel held by a telemetry attachment |
| CValueChannelTelemetryAttachment | Exclusive reader attachment for every telemetry sidecar in one channel set |
| CMeterFrame | A single multi-channel meter reading |
| CPublishCounter | Monotonic publish counter, shared by every value source |
| CMeterSource | Lock-free meter channel: the host publishes a MeterFrame from the audio/host thread; the view reads the latest frame paint-safe |
| CVectorFrame | A block of samples for a scope-style display — an envelope curve, a detector's output, a window of the signal a processor is actually working on |
| CValueEvent | One occurrence inside an audio block |
| CEventFrame | A bounded list of occurrences from one audio block |
| CVectorSource | Lock-free vector channel: the writer publishes a block of samples, the view reads the latest block paint-safe |
| CEventSource | Lock-free event channel: the writer publishes the occurrences from one audio block and the view reads the latest completed block |
| CScalarSource | Lock-free scalar channel: a single paint-safe cached number (a readout value, a modulation ring's base→modulated position) |
| CVisualizationBenchSink | Where the bridge reports its benchmark timings |
| CSpectrumData | Published one-sided amplitude spectrum (lock-free via TripleBuffer) |
| CWaveformData | Published waveform capture (latest buffer snapshot) |
| CVisualizationConfig | Configuration for the visualization bridge |
| CVisualizationBridge | Central visualization bridge: a fixed multichannel audio tap plus a caller-driven, non-RT analyzer and lock-free latest-value publication |
| Nview | Hover-cursor tracking for platform window hosts |
| Ndetail | |
| CDragSessionState | |
| CWebViewBackendProvider | The answer behind detect_webview_backend() and webview_backend_available() |
| Npainters | |
| CKnobStyle | |
| CFaderStyle | |
| CRangeSliderStyle | |
| CToggleStyle | |
| CWaveformStyle | |
| Nmotion | |
| CTraceOptions | |
| CProvenance | |
| CSampleEvent | |
| CPublishOptions | |
| CFixtureHeader | Header metadata recorded once at the top of a fixture file |
| CFixtureDiff | Comparison result from assert_matches |
| CItem | |
| CFixtureMatchOptions | |
| CScalarSample | Flatten a fixture's events into a (time, value) series for one (view, metric, component) triple |
| CInputRecorder | Recording handle returned by make_input_recorder |
| CTraceHandle | |
| CTraceBuilder | |
| CCoordinator | Process-wide singleton that owns one FrameClock subscription, holds the active trace set, and dispatches sample events to registered sinks |
| CCostSample | Per-frame cost attribution sample |
| CRenderCostSnapshot | Snapshot of render-layer cost for the current frame |
| CCostAttributor | Process-wide cost attribution stream |
| Natspi | |
| CStateSet | Two-word AT-SPI state bitfield (the au GetState returns: [low, high]) |
| Nuia | |
| CPatternSet | Pattern IDs the provider should advertise for a given role |
| CRuntimeId | Build the two-element runtime-id key for the fragment at index (its depth-first position among accessible fragments, root excluded) |
| Nwin_input | |
| CInputRouterHost | The native operations the router needs but must not perform itself |
| CPluginInputRouter | Pointer/keyboard/text routing for one plug-in editor window |
| CPointerSession | Host-neutral model of the single Win32 capture bracket owned by an editor |
| CTerminal | |
| CSurfaceLifecycle | Tracks whether the Windows editor host currently owns a GPU/Skia surface pair |
| Nrmlui | |
| CProductEvent | |
| CLuaHost | |
| CElementRegistration | |
| CElementHost | |
| CProductHost | |
| CHostBridge | |
| CImporterCapabilityReceipt | |
| CImporterAdapter | |
| Nweb | |
| CViewportMapping | Maps CSS pixels — the unit every browser pointer event reports — to root-view coordinates |
| CBackingStore | Canvas backing-store size and the scale factor handed to the Skia surface |
| CBrowserModifiers | |
| CBrowserPointerEvent | |
| CBrowserWheelEvent | |
| CBrowserKeyEvent | |
| CWebInputRouter | Routes translated browser events into a live View tree |
| CABCompare | |
| CAccessibilityValueInterface | Interface for accessible values (sliders, knobs, progress bars) |
| CAccessibilityTextInterface | Interface for accessible text content (text editors, labels) |
| CAccessibilityTableInterface | Interface for accessible tables and lists |
| CAccessibilityCellInterface | Interface for individual table cells |
| CAccessibilityInterfaceSet | The accessibility interfaces a View can actually serve |
| CAccessibilityNodeSnapshot | |
| CAnchorDisambiguation | One derived anchor a collision pass replaced |
| CStaticAnimationLimits | Compile-time animation limits for optimization |
| CTween | |
| CAnimationManager | |
| CAnimationId | |
| CValueAnimation | Lightweight, embeddable value animator for widget members |
| CKeyframe | A single keyframe: offset (0-1) and value |
| CKeyframeAnimation | Multi-step keyframe animation with iteration, direction, fill mode |
| CAnimationStep | A step in an animation sequence — either a tween or a parallel group |
| CTweenStep | Single tween step |
| CParallelStep | Parallel group — all steps run simultaneously |
| CAnimatorSetBuilder | Builder for composing animation sequences and parallel groups |
| CRunner | Run the built animation. Advances through sequence, returns true when all done |
| CVector3D | |
| CQuaternion | |
| CDraggable3DOrientation | Draggable 3D orientation — arcball rotation from mouse drag |
| CKeyShortcut | A keyboard shortcut (key + modifiers) |
| CCommand | A named command with optional shortcut and callback |
| CKeyMapping | Manages keyboard shortcuts with configurable bindings |
| CMenuBar | Cross-platform menu bar descriptor |
| CMenuItem | |
| CMenu | |
| CNativeToolbar | Native-toolbar descriptor — a lightweight config struct for host-level toolbars |
| CItem | |
| CAppSettings | Persistent application settings (window size, device selection, preferences) |
| CWindowState | |
| CTextRun | One piece of painted text, resolved to screen space |
| CAppearanceCoverage | N of M evaluated, K skipped and why. Printed on every run |
| CAppearanceFinding | |
| CAppearanceReport | |
| CAppearanceOptions | |
| CAppearanceTracker | Tracks OS-level appearance (light/dark mode) and auto-switches themes |
| CThemeManager | Manages the connection between AppearanceTracker and Theme switching |
| CImageData | Raw pixel data (RGBA 8-bit per channel) |
| CFontData | Font data loaded from TTF/OTF |
| CShaderData | Shader source with optional compilation error |
| CBlobData | Raw binary data for any resource |
| CAssetManager | |
| CAutoUi | |
| CSizeHint | Logical-pixel size that fits AutoUi's generated grid without clipping |
| CBindingAttempt | One recorded attempt, successful or not |
| CBorderShades | The two shades a 3D border style paints a side colour in, as Chromium resolves them |
| CBorderBands | How a side of width CSS px splits into bands for style: an outer band, a transparent gap, and an inner band, summing to width |
| CCornerRadii | A box's corner radii, each corner with a horizontal and a vertical radius |
| CBandedBorder | A banded border in its own border box, origin at the top-left corner |
| CBreadcrumb | |
| CItem | |
| CBubbleMessageComponent | |
| CTextButton | |
| CHyperlinkButton | |
| CArrowButton | |
| CShapeButton | |
| CImageButton | |
| CResizableCorner | |
| CCalloutStyle | Tunables for the callout geometry. All lengths in the window coordinate space |
| CCalloutPlacement | Resolved placement in the window coordinate space |
| CAnchoredCallout | A view-tree callout: hosts one content child, anchored to a target rect with a pointer triangle, auto-flipping + edge-clamping against a window rect |
| CNativeCanvasPaintContext | Per-paint metadata for native, retained CanvasWidget content |
| CNativeCanvasPainter | Retained native painter installed on a CanvasWidget |
| CCanvasDrawCmd | A draw command recorded from JS for replay in paint() |
| CCanvasWidget | A View whose paint() replays a list of recorded draw commands |
| CNativeGpuTextureFrame | |
| CCaretBlinkConfig | Blink timing. The defaults are the values Pulp has always used |
| CCaretBlink | The "solid while moving, blinking while still" state machine |
| CCaretMetrics | Where a caret goes, in the coordinate space the widget paints text in |
| CChannelStripView | |
| CChartShaderPresetOptions | |
| CChartShaderPreset | |
| CCodeEditorConfig | Configuration for the code editor |
| CCodeEditor | Native code editor widget with gutter, language mode, and lightweight token coloring |
| CSystemTrayIcon | System tray icon (macOS NSStatusItem, Windows Shell_NotifyIcon) |
| CFileBasedDocument | FileBasedDocument — document model with save/load/dirty tracking |
| CRecentlyOpenedFilesList | RecentlyOpenedFilesList — persistent MRU list |
| CToken | One token span — half-open [start, start+length) into the line |
| CColorPicker | |
| CCommandInfo | Metadata for one command |
| CCommandHandler | Interface implemented by any object that can perform commands |
| CShortcutMap | (KeyCode, modifiers) → CommandID lookup table |
| CChord | All chords currently bound to the given command |
| CCommandRegistry | Central command dispatcher |
| CComponentDragger | |
| CConcertinaPanel | |
| CContextMenu | Floating, view-tree-drawn context / popup menu |
| CItem | |
| CMenuLayout | The menu's resolved geometry: the panel rect and one rect per row, in this view's LOCAL coordinates |
| CModulationLane | A lane is the product-independent state needed by the standard two-LFO modulation popup |
| CModulationMenuSpec | |
| CCssEasing | CSS easing function — maps a normalized progress t ∈ [0,1] to an eased progress p ∈ [0,1] |
| CTransitionSpec | One transition spec — one CSS property with its own duration / delay / easing |
| CCssAnimation | One running animation |
| CCssKeyframe | One @keyframe stop |
| CCssKeyframesBlock | One @keyframes block: name + ordered stops |
| CCssKeyframesRegistry | Application-wide registry for @keyframes blocks |
| CCustomShaderHost | Mixin for widgets whose body can be painted by a custom SkSL shader |
| CShaderValueBinding | |
| CShaderScopeBinding | |
| CLevelDisplay | Generic level, series and bin display seams owned by view-core |
| CSeriesDisplay | |
| CBinDisplay | |
| CDataDisplayCatalogRow | |
| CDataDisplayRegistration | |
| CCodeGenOptions | Options for code generation |
| CCppExportOptions | |
| CCppExportResult | |
| CSwiftExportOptions | |
| CSwiftExportResult | |
| CDesignExport | Export a Theme's design tokens to various output formats |
| CDesignMdProseHints | |
| CFidelityIssue | A single import-fidelity self-check finding |
| CFidelityContext | Everything a check needs: the node, its sanitized bridge id, the dimensions codegen emitted for it, and which branch produced them |
| CFidelityKindInfo | One entry in the named fidelity taxonomy: the stable kind slug the checks emit, its typical severity, and what it means |
| CFidelityLedgerMeta | Provenance recorded in the ledger header |
| CDesignFitView | Uniformly scales one fixed-size subtree to fit this view's bounds — the SUB-VIEW analogue of WindowHost::set_design_viewport |
| CDesignFrameElement | |
| CDesignControlContext | |
| CDesignControl | |
| CUnregisteredCustomControl | |
| CParamScaleMismatch | |
| CDesignFrameView | |
| CPanelTransform | |
| CDesignTabGroup | |
| CDesignStepper | |
| CImportReportEntry | |
| CImportReport | |
| CUnrenderableFrameSet | |
| CDuplicateAnchor | |
| CNativeMaterializeOptions | |
| CNativeImportBindingOptions | |
| CNativeImportBindingDescriptor | |
| CNativeImportSegmentedBindingDescriptor | |
| CNativeImportStepperBindingDescriptor | |
| CNativeImportXYPadBindingDescriptor | |
| CNativeImportMeterBindingDescriptor | A level display's binding |
| CNativeImportChoiceBindingDescriptor | |
| CNativeImportWaveformBindingDescriptor | |
| CNativeImportTextBindingDescriptor | |
| CNativeImportHostActionDescriptor | |
| CNativeImportBindingContext | |
| CNativeImportComboBoxBindingContext | Optional capability for binding a collapsed selector |
| CIRBoxShadow | A single CSS box-shadow layer |
| CIRStyle | Style properties for an IR node |
| CClipRect | |
| CRenderBounds | |
| CIRLayout | Layout properties for an IR container node |
| CIRProvenance | Adapter-side provenance: who lowered this node, from what source |
| CIRTextLineBox | One styled character range inside a text node |
| CIRTextLayoutBasis | What the cached line boxes above were laid out AGAINST |
| CIRTextRun | |
| CIRInteractiveElement | |
| CIRNode | |
| CImportDiagnostic | |
| CIRAssetRef | |
| CIRAssetManifest | |
| CIRFontAsset | A bundled (non-system) font shipped with the design (figma-plugin #43a: envelope font_family_assets[]) |
| CIRTokenIdentity | |
| CIRTokens | Design token collection (W3C-compatible) |
| CDesignIR | Complete design IR document |
| CDesignIrJsonOptions | |
| CDesignIrAssetOptions | |
| CDesignIrParseError | Thrown by parse_design_ir_json for input that is not well-formed JSON: truncated documents, unterminated strings or escapes, unbalanced or over-deep nesting, embedded NUL bytes, and anything the JSON parser itself refuses |
| CLineMetrics | A text run's primary-font ascent and descent in CSS px, as the browser rounded and adjusted them when it built the run's content area |
| CDesignParamBinding | |
| CDetectedShortcut | |
| CDefaultShortcutCandidate | One default-binding emission produced by the source heuristic |
| CDefaultShortcutCollision | One unresolved candidate set — emitted when multiple components match the same pattern with comparable confidence |
| CDefaultShortcutScan | Result of running detect_default_shortcuts |
| CSnapshotDynamicApiScan | |
| CDesignMdDiagnostic | |
| CDesignMdOmittedSection | |
| CDesignMdParseResult | |
| CDesignMdTokenDiff | |
| CDesignMdDiffResult | |
| CClaudeBundleAsset | One asset entry from a Claude Design bundle |
| CClaudeBundleFontBinding | One captured @font-face rule joined to a content-addressed bundle asset |
| CClaudeBundleMaterializedBinding | One id-addressed binding from a v2 materialized browser document |
| CClaudeBundle | Result of unpacking a Claude Design bundle's <script type="__bundler/manifest"> |
| CMaterializedDocumentCacheStats | |
| CClaudeRuntimeOptions | Options for the --execute-bundle import lane |
| CDesignSlot | |
| CDesignChildUpdate | |
| CDesignKeyDiagnostic | |
| CDesignUpdateBlock | |
| CDesignUpdateWorkCounters | |
| CDesignChildUpdatePlan | |
| CDesignedControlSkin | Colours and geometry for the value layer, taken from the design's own tokens so the ring belongs to the palette that asked for it |
| CDropData | |
| CDropReceiver | |
| CDropTarget | |
| CDragSource | |
| CFileDragRequest | |
| CDragSession | |
| CActiveDrag | |
| CEditorBridge | Renderer-agnostic dispatcher for editor↔processor JSON messages |
| CFileBrowser | File browser component with directory navigation, file list, and preview panel |
| CFileTree | File tree component — tree-structured directory view |
| CFileTreeNode | |
| CContentSharer | Content opener for files and text |
| CMultiDocumentPanel | Multi-document panel — tabbed container for multiple document views |
| CFileChooser | Builder-style file chooser |
| CFileDropZone | |
| CFrameClock | |
| CFrameCostProbe | |
| CFrame | |
| CSummary | |
| CBudget | |
| CBadge | |
| CInlineBanner | |
| CToast | |
| CEmptyState | |
| CStepper | |
| CPanControl | |
| CPopover | |
| CInCanvasDialog | |
| CChannelStrip | |
| CSpinner | |
| CNumberBox | |
| CPoint | |
| CSize | |
| CRect | Axis-aligned rectangle in continuous (float) coordinates |
| CIntRect | Axis-aligned rectangle in DISCRETE (integer) coordinates |
| CDimension | |
| CFlexStyle | |
| CGridTrack | Grid track size: fixed px, fractional (fr), or auto |
| CGridStyle | Grid layout properties (CSS Grid Level 1 subset) |
| CNamedArea | Named-area grid |
| CGestureContext | |
| CGestureRecognizer | |
| CTapRecognizer | |
| CLongPressRecognizer | |
| CPanRecognizer | |
| CSwipeRecognizer | |
| CFlingRecognizer | |
| CPinchRecognizer | |
| CRotateRecognizer | |
| CGestureArbiter | |
| CGpuAcquireDiagnostics | |
| CLogFrequencyScale | Maps frequency (Hz) to a horizontal pixel position on a logarithmic axis |
| CDecibelScale | Maps decibels to a vertical pixel position on a linear axis (dB is already logarithmic in amplitude, so the axis itself is linear in dB) |
| CGroupBoxView | |
| CHitMetrics | Minimum hit-target sizing for one pointer type |
| CHostDragCoalescer | Owns a PointerCoalescer plus the host-side policy around it: the frame-driver opt-in, the idle->pending dirty edge, and the counters |
| CSubmitResult | What a host must do in response to a submitted sample |
| CStats | |
| CHostFramePump | Converts a host's monotonic presentation timestamps into per-frame deltas |
| CHostFrameTick | Result of begin_host_frame |
| CHostFrameTimeRecorder | Keeps the first kMaxSamples frame durations |
| CHotReloader | |
| CHoverCursorTracker | Remembers the pointer position and the style last handed to the platform |
| CDecodedImage | |
| CImageCacheStats | |
| CImageCache | |
| CInlineValueEditorView | |
| CMouseEvent | Rich mouse/pointer event with position, modifiers, button state, pointer ID, and stylus properties |
| CGestureEvent | High-level gesture event for pinch (scale) and rotate |
| CKeyEvent | Rich key event with key code, modifiers, and repeat state |
| CTextInputEvent | Text input from IME or keyboard composition (separate from KeyEvent) |
| CViewInspector | |
| CInspectorFacts | Lets a widget describe itself to the component inspector (ViewInspector) and to view-core's layout and appearance diagnostics without either naming its class |
| CFact | |
| CInspectorHighlight | Highlight overlay added to the target root to visualize the selected view bounds |
| CInspectorWindow | Floating inspector window that displays the view hierarchy and properties of a target view tree in a separate OS window |
| CHostObjectProperty | |
| CHostObjectMethod | |
| CHostObjectDescriptor | |
| CJsEngineCreationStats | |
| CJsEngine | |
| CScriptBytecodeCacheStats | Process-wide reuse of compiled script bytecode (QuickJS backend) |
| CEngineRecommendation | |
| CJsxLockTweak | A single tweak to promote into authored JSX/TSX source |
| CJsxLockResult | Result of locking one tweak into an authored JSX/TSX source string |
| CKeyMappingEditor | |
| CKnobModulationView | |
| CSelectionRect | Rectangle in parent coordinates |
| CLassoComponent | Lasso (rubber-band) selection overlay |
| CLayoutTreeSnapshotOptions | |
| CLayoutTreeTolerance | |
| CLayoutTreeDiff | |
| CLiveConstant | A single live-editable constant |
| CLiveConstantRegistry | Registry of live constants — thread-safe singleton |
| CLiveConstantEditor | Debug overlay that shows sliders for all live constants |
| CLockToSourceTweak | A single tweak to promote into source |
| CLockResult | Result of locking one tweak into a generated source string |
| CReparentToSourceEdit | A single structural reparent to promote into source: move the element anchored by child_anchor_id to become a child of the element anchored by new_parent_anchor_id |
| CLottieView | |
| CModalOverlay | A modal overlay that captures focus and dims the background |
| CModelManagerView | |
| CModRoute | |
| CModulationMatrix | |
| CModulationMatrixWidget | |
| CEndpoint | Populate the source + destination labels |
| CMotionPreferences | Process-wide reduced-motion preference tracker |
| CNativeViewHost | A Yoga-laid-out widget that embeds a single platform-native child view (a system WebView, a native text field with IME + OS accessibility, a video / camera layer, an OS picker) inside Pulp's GPU-painted view tree |
| CNumberBoxStatesView | |
| COverlayPressTarget | |
| COverlayDismissalPolicy | Tunable defaults for the dismissal policy |
| CPassivePointerRoute | Where a PASSIVE pointer input — a wheel / two-finger scroll, a trackpad magnify or rotate — at root_pt goes while overlays may be open |
| CContextPressResult | What a context (right-button) press resolved to |
| CParamSubscription | A live onParamChanged registration |
| CParameterBinding | RAII owner of a widget↔parameter binding's store listener |
| CPendingDamage | Accumulated repaint damage for one frame, in root/window coordinates |
| CSnapshot | One frame's damage, taken atomically out of a PendingDamage |
| CFrameGeometry | The size/scale/viewport a frame is painted against, in one value |
| CPluginKeyOffer | Platform-supplied facts about the key that core/view cannot derive from a KeyEvent alone |
| CPluginViewHost | |
| CSize | |
| COptions | |
| CGpuCacheUsage | Bytes held by this host's GPU resource caches: budgeted against Skia's budget, purgeable what a trim can return |
| CGpuSurfaceStatus | |
| CGpuSurfaceSubscription | |
| CPointerSample | One pointer sample as the host received it, before any coalescing |
| CPointerCoalescer | Collapses runs of motion into one sample per presented frame while leaving button transitions untouched and in order |
| CPointerAttributes | Device identity of the pointer a delivery verb is dispatching, stamped onto every MouseEvent the verb builds (including the ancestor-bubble copies) |
| CWheelHost | Host hooks the portable wheel router calls back into |
| CMouseDownHost | Optional host-owned continuation check for re-entrant press delivery |
| CMouseUpHost | Host hooks the portable mouse-up router calls back into |
| CPreferencesPanel | |
| CPage | |
| CPresetBrowser | Preset browser widget with list display, search filtering, category grouping, and prev/next navigation |
| CPressReach | What a press at a point resolves to, WITHOUT delivering it |
| CUnreachablePressTarget | One control that advertises a press target but cannot be reached by a press at the rect it paints |
| CPressReachAudit | What an audit examined, so a caller can tell a clean tree from a blind one |
| CPressReachOptions | Tuning for audit_press_reach |
| CPropertyList | |
| CProperty | |
| CPropertyPanel | |
| CProperty | |
| CPropertyPanelView | |
| CQueryOptions | |
| CQueryService | |
| CRangeSliderView | |
| CRecognitionEntry | One recognition source: a flat map of a designer's component identity to the Pulp control it materializes |
| CRecognitionSource | A named bundle of recognition entries from one origin (built-in library, user manifest, or — later — an installed package) |
| CResolvedControl | The result of resolving one node's identity against the merged table |
| CRecognitionResolver | The single merge layer |
| CUnmatchedComponent | Apply the resolver to a parsed figma-plugin IR tree IN PLACE: for every node that carries a Figma component identity (attributes figmaComponentKey / figmaMainComponentName, stamped by parse_ir_node) but is NOT already a recognized audio widget, resolve it against the merged table and stamp audio_widget (built-in kinds) on a match |
| CPackageDesignControlSources | |
| CRelativeExpression | |
| CRelativePoint | |
| CCapabilitySet | A granted-capability set |
| CReorderList | Single-axis drag-to-reorder container |
| CDamageDecision | The result of the damage decision |
| CResizableShellConfig | |
| CResizableShell | |
| CCaptureRequirements | |
| CCaptureResult | |
| CCompareResult | Result of comparing two screenshots |
| CDiffBounds | Bounding box of changed pixels between two screenshots |
| CScreenshotContentStats | Basic content statistics for a decoded PNG |
| CPngMetadata | Decoder-independent PNG structure and dimensions |
| CScriptEngine | |
| CScriptInspectorBridge | |
| CEvalResult | |
| CCapabilities | |
| CScriptInspectorPort | The engine-thread half of a runtime inspector, as ScriptedUiSession drives it |
| CScriptedEditorSession | The part of a scripted editor session that editor hosts drive: the frame pump, the content-first open, GPU-surface handoff, and teardown |
| CScriptedUiOptions | |
| CScopedDeferredDocumentLoad | View-first editor opening |
| CScriptedUiSession | |
| CReloadMetrics | JS-axis reload timings, ms |
| CScriptedUiPrewarmRequest | |
| CScriptedUiPrewarmStats | |
| CScrollBar | Standalone, parameter-style scrollbar |
| CSdlWindowHost | |
| COptions | |
| CSelectableLine | One painted line of selectable text, in the widget's LOCAL coordinates |
| CSelectableLayout | The painted line geometry of one widget |
| CSelectableText | A widget whose painted text can join a document-level selection |
| CSidePanel | |
| CSliderCore | |
| CSplashScreen | |
| CSplitView | |
| CSpriteStrip | A filmstrip image containing N frames of a control at different values |
| CFragmentTransform | |
| CSvgPathSegment | Parsed path segment — flat, allocation-light, ready to replay onto a Canvas in a single pass during paint() |
| CSvgPathWidget | Renders an inline SVG <path d="..."> icon |
| CTableColumn | Column definition for TableListBox |
| CTableModel | Data model for TableListBox — implement this to provide row data |
| CSimpleTableModel | Simple in-memory table model backed by a vector of string vectors |
| CTableListBox | Scrollable table with sortable columns |
| CTableCell | |
| CTextAccessibilityNode | A single accessible text node — the minimum a screen reader needs to describe a piece of painted text |
| CTextEditor | Text editing widget with comprehensive keyboard/mouse interaction |
| CTheme | |
| CContrastIssue | |
| CThemeEditor | Interactive theme editor widget — displays all color tokens as editable swatches |
| CSemanticColors | Semantic color tokens from tweakcn/shadcn-ui (the base 11 + 5 chart colors) |
| CThemePreset | A theme preset with light and dark variants |
| CTokenTarget | A tweak classified as targeting a design token |
| CTokenLockResult | Outcome of a lock_token_in_designmd call |
| CToolbarItem | Single toolbar item |
| CToolbar | Toolbar container |
| CTooltipWindow | |
| CTracingBadgePlacement | |
| CTracingBadgeLayout | |
| CTreeNode | A node in the tree hierarchy |
| CTreeView | Hierarchical tree view widget |
| CComboBox | Drop-down selector for enumerated parameters |
| CTooltip | Hover tooltip that displays text near a target view |
| CThemeModeControl | Compact 3-segment control to pick the theme mode: system / light / dark |
| CProgressBar | Visual progress indicator for long-running operations |
| CCallOutBox | Floating alert/notification box |
| CTabPanel | Tabbed container that shows one child at a time |
| CTab | |
| CSegmentedControl | Horizontal segmented selector — a row of mutually-exclusive labeled segments sharing one inset track, with the selected segment raised as an "elevated" pill (the Ink & Signal navigation treatment, Figma 227:1763) |
| CScrollView | Scrollable container that clips and scrolls its content |
| CListBox | Scrollable list of selectable items |
| CFrameClockBinding | Subscription lifecycle for a view that pulls a value once per frame |
| CMeterSourceBinding | Binds a MeterSource channel and caches the latest frame for paint |
| CScalarSourceBinding | Binds a ScalarSource and caches the latest value for paint |
| CViewCapture | Identity-safe reference to a View captured across native event boundaries |
| CView | |
| CSimulatedPointer | Device identity of a synthesized pointer gesture |
| CHitSlop | React Native hitSlop — extra hit-test area OUTSIDE the painted box |
| CSourceLocation | Authored-source location for this view |
| CBoxShadow | Box shadow (CSS-like: offset, blur, spread, color, inset) |
| COverlayRequest | Deferred overlay paint callback |
| CRootInteractionState | |
| CFilterOp | Full CSS filter chain |
| CStagedAnimation | Staged CSS animation control tokens |
| CBackgroundGradient | One background-image layer |
| CResolvedRadial | A radial gradient's centre and radii in pixels, resolved against a box |
| CDispatchLease | RAII gate held across any call into overridable View code |
| CViewPool | Per-class recycling pool for View objects |
| CVirtualGrid | Recycling virtualized 2D grid for large, scrolling, rich cell views |
| CVirtualListDirtyTracker | |
| CRect | |
| CVirtualList | Recycling virtualized list for large, scrolling, rich row views |
| CWaveformRegion | A region (selection or marker) within the waveform |
| CWaveformEditor | Interactive waveform editor for audio file editing and sample selection |
| CWaveformSampleRange | Sample range in source-frame coordinates. End is exclusive by convention |
| CWaveformViewport | Immutable-for-paint viewport state and sample/pixel conversion rules |
| CWaveformRenderSpan | One pixel/column span for waveform min/max reduction or GPU upload planning |
| CWaveformRenderPlan | Opt-in geometry plan. Callers decide when span allocation is acceptable |
| CWaveformHandle | |
| CWaveformHandleModel | Editor handle state without rendering, input events, or audio ownership |
| CWaveformHitResult | |
| CWaveformSnapSettings | |
| CWaveformSnapResult | |
| CWaveformPlayheadOverlay | |
| CWaveformEditorTransactionResult | |
| CWaveformEditorTransaction | Semantic edit transaction state. Platform input translation stays in widgets/views |
| CWaveformEditorSurfaceSnapshot | |
| CWaveformEditorSurfaceEditResult | |
| CWaveformEditorSurface | View-layer editing surface that composes waveform primitives without owning audio or painting |
| CWebViewOptions | |
| CResource | |
| CWebViewMessage | |
| CWebViewEmbeddedAsset | |
| CWebViewPanel | |
| CWidgetReloadSnapshot | |
| CXYValue | |
| CWidgetBridge | |
| CEmbeddedAsset | One file compiled into the plug-in beside its editor script |
| CDamageLedger | What the tree had marked when a batch of script work started, so the bridge can tell whether that work already asked for exactly the repaints it needs (see View::damage_request_count()) |
| CFontSpec | A font request, as a delegate expresses it |
| CEdgeInsets | Per-side insets in pixels |
| CMenuItemMetricsQuery | What a menu row is, when the delegate is asked how big it should be |
| CBoxSize | A control's natural size |
| CWidgetMetrics | Install on a View to supply the SIZES of the controls in its subtree |
| CControlPaintState | State every control hands to its painter |
| CRotaryPaintState | A rotary control |
| CLinearPaintState | A linear control (fader / slider / scroll thumb) |
| CButtonPaintState | A push / toggle button |
| CComboBoxPaintState | A dropdown field (the closed control, not the open list) |
| CMenuBackgroundPaintState | A menu panel's backing surface. bounds is the whole panel |
| CMenuItemPaintState | One menu row. bounds is the row rect within the menu panel |
| CMenuHeaderPaintState | A menu section title row |
| CTextFieldPaintState | A text field's frame |
| CCaretPaintState | The text-insertion caret |
| CWidgetPainter | Install on a View to supply the pixels for the controls in its subtree |
| CSkinImage | Derives native-widget skin styling from a captured design asset (a flat PNG exported by a design tool such as the Figma plugin) |
| CFaderSkin | Derived fader skin |
| CMeterSkin | Derived meter skin: gradient stops ordered low→high (bottom→top), plus an optional background color |
| CLabel | |
| CPaintedTextExtents | The extents of the glyphs this Label will actually paint, given the content width it has been laid out at |
| CCachedLineBox | One captured line of text: where it sits in this Label's box, and which slice of the text it holds (UTF-16 code units, as the capture indexes) |
| CLineBreakPathCounts | How many Labels took each line-breaking path since the last reset |
| CTextEditMetrics | WYSIWYG text-edit metrics — the geometry an inspector edit overlay needs to draw a caret + selection band that EXACTLY matches the glyphs paint() renders |
| CKnob | |
| CModulationRing | |
| CFader | |
| CRangeSlider | |
| CChromiumRefreshParts | Everything the chromium_refresh skin paints, in local coordinates |
| CToggle | |
| CCheckbox | |
| CChromiumRefreshParts | Everything the chromium_refresh skin paints, in local coordinates, in paint order: lighten (disabled only), background, border (absent for a checked or indeterminate checkbox), accent_fill (checked or indeterminate checkbox), then the mark: the check stroke, the dash or the radio dot |
| CButtonSurface | |
| CChromiumRefreshParts | Everything the skin paints, in local coordinates, in paint order: the lighten layer (disabled only) and fill on surface, the border stroke on surface, then, when focus-visible, the outer ring and the inner ring over it |
| CToggleButton | |
| CIcon | |
| CImageView | |
| CXYPad | |
| CPanel | |
| CGroupBox | |
| CDualRangeSlider | |
| CInlineValueEditor | |
| CWaveformRecorder | |
| CSvgLineWidget | Renders an inline SVG <line x1 y1 x2 y2 stroke stroke-width /> |
| CSvgRectWidget | Renders an inline SVG <rect x y width height fill stroke
stroke-width /> |
| CDocumentWindow | |
| CMenuItem | A menu item in this window's menu bar |
| CMenu | A top-level menu (e.g. "File", "Edit", "View") with its items |
| CDialogWindow | |
| CAlertWindow | |
| CStyleTokens | Theme color-token names the host should look up when painting each AlertIcon |
| CWindowOptions | |
| CMenuCommand | |
| CWindowHost | |
| CContentSize | |
| CMonitorInfo | Monitor information |
| CScreenInfo | |
| CWindowState | |
| CWindowRecord | |
| CWindowMessage | |
| CWindowManager | |
| CAudioWaveformView | Time-domain waveform plot over a copied, fixed-capacity sample buffer |
| CAudioInspectorPanel | Audio Inspector content panel |
| CAudioInspectorWindow | Floating Audio Inspector window |
| CMeter | |
| CWaveformView | |
| CSpectrumView | |
| CEqCurveView | |
| CBand | |
| CBandParamIds | |
| CMidiKeyboard | |
| CMusicalTypingController | |
| CMusicalTypingKeyboard | |
| CSampleAssetDropPlan | |
| CSampleAssetDropTarget | DropTarget adapter for sampler/import UIs |
| CStepGridViewBase | |
| CCellVisual | Precomputed per-cell visual, recomputed only for dirtied regions |
| CPumpResult | Result of one pump(), surfaced for headless tests (a hostless view cannot observe request_repaint()) |
| CCell | |
| CEchoResult | |
| CResyncPoint | |
| CPlayheadProjection | |
| CDefaultCellPolicy | Primary template is deliberately undefined-usable: a custom cell type must supply its own CellPolicy (visual + make_set_cell), else it is a compile error rather than a silent blank / uneditable grid |
| CDefaultCellPolicy< state::StepCell > | |
| CStepGridViewT | |
| CSpectrogramView | |
| CMultiMeter | |
| CCorrelationMeter | |
| CWaveformPeakVertex | |
| CWaveformGpuUploadKey | |
| CWaveformGpuLayerConfig | |
| CWaveformGpuStaticLayerPlan | |
| CWaveformGpuLayerPlan | |
| CWaveformGpuResourceRecord | |
| CWaveformGpuResourceCacheStats | |
| CWaveformGpuResourcePutResult | |
| CWaveformGpuResourceCache | Metadata-only LRU for backend-owned waveform resources |
| CWaveformGpuRenderContext | |
| CWaveformGpuRenderDecision | |
| CWaveformGpuRenderController | Stateful policy helper for backend-owned waveform resources |
| CWaveformHeadlessRenderConfig | |
| CWaveformHeadlessRenderFrame | |
| CWaveformHeadlessRenderBackend | Headless backend adapter over WaveformGpuRenderController |
| CWaveformOverviewView | A View that renders a pre-decoded min/max peak overview as vertical columns |
| CWaveformRecorderView | |
| CEventFrame | A bounded list of occurrences from one audio block |
| CEventSource | Lock-free event channel: the writer publishes the occurrences from one audio block and the view reads the latest completed block |
| CHostActionSurface | A framework-agnostic host command channel |
| CHostParamSurface | A framework-agnostic, native-view-facing runtime parameter accessor |
| CMeterFrame | A single multi-channel meter reading |
| CMeterSource | Lock-free meter channel: the host publishes a MeterFrame from the audio/host thread; the view reads the latest frame paint-safe |
| CScalarSource | Lock-free scalar channel: a single paint-safe cached number (a readout value, a modulation ring's base→modulated position) |
| CStateStoreHostParamSurface | The native (Pulp Processor::create_view()) backing for HostParamSurface, implemented over a StateStore |
| CValueChannelSet | A processor's declared channels |
| CValueChannelTelemetryAttachment | Exclusive reader attachment for every telemetry sidecar in one channel set |
| CVectorFrame | A block of samples for a scope-style display — an envelope curve, a detector's output, a window of the signal a processor is actually working on |
| CVectorSource | Lock-free vector channel: the writer publishes a block of samples, the view reads the latest block paint-safe |
| CValueChannelInfo | What a channel is, for discovery and for a UI lint to check names against |
| CValueChannelTelemetryDescriptor | Stable metadata for a channel held by a telemetry attachment |
| CValueChannelTelemetryEventBatch | One producer event batch retained by the ordered telemetry tap |
| CValueChannelTelemetryEventStats | Current producer-tap state. Overflow is cumulative for the source lifetime |
| CValueChannelTelemetrySnapshot | A coherent continuous payload copied by the existing UI reader path |
| CPublishCounter | Monotonic publish counter, shared by every value source |
| CValueEvent | One occurrence inside an audio block |
| CAudioBridge | |
| CMeterBallistics | |
| CMeterData | |
| CSpectrumData | Published one-sided amplitude spectrum (lock-free via TripleBuffer) |
| CVisualizationBenchSink | Where the bridge reports its benchmark timings |
| CVisualizationBridge | Central visualization bridge: a fixed multichannel audio tap plus a caller-driven, non-RT analyzer and lock-free latest-value publication |
| CVisualizationConfig | Configuration for the visualization bridge |
| CWaveformData | Published waveform capture (latest buffer snapshot) |
| Nevents | |
| CConnectedChildProcess | A child process with a bidirectional IPC channel |
| CChildProcessManager | Manages a pool of child processes |
| CCoalescedUpdater | Coalescing async update — trigger from any thread, callback runs on event thread |
| CLambdaCoalescedUpdater | Lambda-based async updater (convenience) |
| CMultiTimer | MultiTimer — manages multiple named timers from a single object |
| CActionBroadcaster | ActionBroadcaster — string-based action dispatch (for menu commands, etc.) |
| CScopedLowPowerModeDisabler | ScopedLowPowerModeDisabler — prevents OS power throttling during audio processing |
| CEventLoop | |
| CProduct | Resolved product metadata |
| CProductLookupResult | Outcome of a single product lookup invocation |
| CPurchase | Single transaction record |
| CIapClient | Cross-platform in-app purchase surface |
| CInterprocessConnection | Interprocess connection — send and receive length-prefixed messages |
| CInterprocessConnectionServer | Interprocess connection server — listens for multiple client connections |
| CMainThreadDispatcher | |
| CBackend | |
| CMessageLoopIntegration | Cross-platform introspection of the active main loop |
| CLocalNotification | Posted notification descriptor |
| CNotificationActivation | Delivered to set_handler() when the user activates a notification |
| CPushNotifications | Cross-platform local notification surface |
| CServicePublisher | RAII service publisher |
| CServiceBrowser | RAII service browser |
| CTimer | |
| CMountedVolumeListChangeDetector | Detects when volumes are mounted or unmounted |
| CNetworkServiceDiscovery | MDNS-based network service discovery (Bonjour/DNS-SD) |
| CService | |
| CBackend | Backend interface the host installs to get real mDNS |
| CLockingCoalescedUpdater | Locking variant of CoalescedUpdater — blocks the trigger thread until the update is processed on the event thread |
| Nformat | What the product grants a device: the quota table indexed by capability tier and live thermal state |
| Naax | |
| CEditorHost | The editor-facing surface of the AAX data model |
| CEditorSizePlan | How the editor surface reacts to the size AAX gives it |
| CParameterIdMap | state::ParamID → the AAX parameter-ID string the model registered under |
| CParameterMirror | Writes editor-store changes back to the AAX parameter manager without the two mirrors chasing each other |
| CGestureRouter | Maps StateStore gesture callbacks onto AAX automation touch/release |
| CEntryConfig | |
| CMidiPacketBytes | SDK-free mirror of the fields of AAX_CMidiPacket this layer needs |
| CPluginCodes | |
| CParameterBinding | |
| CComponentLayout | |
| CPluginDefinition | |
| CDefinitionResult | |
| CAaxNativeRect | A native rectangle in the parent's own (logical point) coordinate space |
| CAaxNativeGeometry | Everything the host-frame receipt needs in one read: the parent the host handed down, the child Pulp attached, and the window both sit in |
| Nboundary | |
| CHostTransport | Format-neutral transport snapshot, already decoded from a host playhead into canonical units (quarter-note beats, samples, real BPM) |
| CLatencyCompensatedBypassT | Per-channel dry-signal delay used by an adapter's bypass path |
| CParamSnapshotState | Generation-gated pre-process snapshot: which generation it was taken at and whether it can be trusted |
| CMpeSidecar | Owns the MPE tracker + expression buffer + inbound-offset cursor an adapter wraps around its MIDI decode, plus the descriptor opt-in flag |
| Nara | |
| CAraAudioSource | Properties of an audio source, as reported by the host |
| CAraAudioModification | A user-editable view onto an AraAudioSource |
| CAraTempoEntry | Tempo + meter context shared by one or more region sequences |
| CAraMusicalContext | |
| CAraRegionSequence | A region sequence groups playback regions on the same logical track (host's notion of "track" or "lane") |
| CAraPlaybackRegion | A playback region maps a span of an audio modification onto the host's timeline |
| Nau | Apple-only: the whole header is gated on APPLE so it stays an empty no-op on the Linux header-hygiene check |
| CFactoryPresetTable | The host-facing factory-preset table for one plug-in instance |
| CPulpAUEffect | |
| CPulpEditorContext | |
| COfflineRenderProperty | Host offline-render intent for an AU v2 instance |
| CMidiOutputPacketBuilder | |
| CRenderContextObserverProperty | kAudioUnitProperty_RenderContextObserver, the v2 form of AUv3's renderContextObserver |
| CScopedHostParamWrite | RAII marker for the host-write window. Scoped to the calling thread |
| CParameterDisplayNamePublisher | Coalesces StateStore presentation-name changes and republishes only the affected stable parameter IDs from the host's main thread |
| CMidiOutputCallbackPublisher | Publishes the host's kAudioUnitProperty_MIDIOutputCallback pair from the main thread to the render thread |
| CPair | |
| CPulpAUInstrument | |
| CPulpAUMidiProcessor | AU v2 adapter for a Pulp Processor whose descriptor declares PluginCategory::MidiEffect — an AU MIDI processor, component type aumi (kAudioUnitType_MIDIProcessor) |
| Nclap_adapter | |
| COutboundParamEvent | |
| CPulpClapPlugin | |
| Nclap_generic | |
| CClapPluginRecord | |
| Ndetail | The plugin processor interface |
| CEditorResizeHandlerEntry | |
| CParamEventsOptOutSlot | The parameter-event queues adapters hand to opted-out processors, keyed by address, with a flag param_events() sets when one of them is read |
| CStandaloneTestMidiNote | |
| CStandaloneTestTransportUpdate | |
| CStandaloneTestTransportState | |
| CStandaloneTestInputHost | Bounded control-thread to audio-thread bridge for standalone inspector test input |
| Nlv2_adapter | |
| CLv2PortLayout | The single definition of a Pulp LV2 plugin's port ordering |
| CLv2TimeUrids | URIDs the time:Position decode needs, resolved once in instantiate() |
| CLv2TimePosition | A time:Position object decoded into LV2's own units and conventions |
| CPulpLv2Instance | |
| Nplugin_state_io | |
| CRestoreDiagnosticPolicy | |
| CRestoreDiagnostics | |
| Nrack | |
| CParamSpec | |
| CPortSpec | |
| CLightSpec | |
| CModuleDescriptor | One module: everything needed to emit its panel, its manifest entry, and its widget placement |
| CPluginManifest | A whole plugin: brand plus its modules |
| Nreload | |
| CBuildFingerprint | |
| CKeyMaterial | |
| CSwapStage | One half of a live swap |
| CLiveSwapResult | |
| CSwapUnit | The contract a swappable subsystem implements to join a live-swap transaction |
| CPackBuildResult | |
| CPackInstallResult | |
| CParamSupersetResult | Result of the SUPERSET contract check ("add params and stay live"): a candidate is a valid superset when every LIVE parameter is present in the candidate with an identical contract (existing automation / saved sessions stay valid), and the candidate may ALSO declare new parameters |
| CProcessorHotSwapSlot | |
| CReloadController | |
| CBaseline | The version the controller compares against: the watched file's mtime and content hash it last acted on (or was seeded with) |
| CReloadLibrary | |
| CDspReloadSwapUnit | Adapts a ReloadSession reload-from-library to a SwapUnit |
| CReloadMetrics | DSP-axis reload timings (control-thread, off the audio path) |
| CReloadOutcome | |
| CGatedImage | A logic image that passed the pre-construction gates (reload-ABI version + build fingerprint) with its factory resolved |
| CSwapPackTrust | Trust material for verifying a swap-pack-delivered logic image BEFORE it is loaded |
| CReloadSession | Owns the session-stable state for a series of hot reloads of one plugin instance — the slot, the live store, the host fingerprint, the prepare context, and the retained images — so callers (a standalone shell, a file-watch controller) issue reload(path) without re-threading five coupled arguments, and the lifetime contract is enforced by construction |
| CReloadTrustPolicy | |
| CReloadableShell | |
| CRemoteUpdateResult | |
| CRemoteFetchResult | |
| CFetchedPack | What an injected fetcher returns |
| CRemoteUpdateConfig | |
| CSignedRevocationList | A signed revocation list |
| CSrlVerifyResult | |
| CSrlFloorState | State of the persisted floor for a namespace |
| CEpochFloorStore | Directory-backed store of the highest SRL epoch SEEN, namespaced by (plugin_id + revocation_pubkey_fpr + update_channel) |
| CScriptedUiSwapUnit | |
| CSwapPackFile | |
| CSwapPackManifest | |
| CSwapPackVerifyResult | |
| Nvalidation | |
| CCheckResult | Outcome of a single validation check |
| Nvst3 | |
| CPulpVst3Processor | |
| CContractPlugView | |
| Nwclap | |
| CWebviewContent | |
| CWebviewProvider | |
| Nwam | |
| CWamDescriptorData | |
| CWamParamInfo | |
| CWamTransport | |
| CWamStage | |
| CWamProcessorBridge | |
| CWamChainBridge | |
| CAppUpdateStatus | |
| CAppUpdateService | |
| CAppUpdatesSettingsView | |
| CAraDocumentController | ARA document controller — manages the plugin's view of the DAW's audio content |
| CAudioInputBusProvider | A host-owned, realtime-safe view provider for declared processor input buses |
| CAudioWorkgroupClient | Optional capability for processors and graph runtimes which own auxiliary realtime rendering threads |
| CBackgroundTaskLane | One bounded, pre-warmed audio-to-worker task lane |
| CContractSessionRegistry | The contract sessions one adapter instance opened that a host still holds |
| CContractEditorSession | |
| CHostHooks | What the adapter does for the editor's context |
| CDescriptorIssue | |
| CDeviceQuotas | Ceilings a consumer may grant at one (tier, thermal state) cell |
| CDiagnosticReporter | Collects and formats diagnostic information about the system, plugin configuration, and audio state for troubleshooting |
| CEmbeddedEditorFile | One file embedded beside the editor script |
| CEditorAssets | |
| CParamSubscription | Owns one ParamPort listener registration |
| CParamPort | Parameter access for an editor |
| CStateStoreParamPort | The default ParamPort, over a processor's StateStore |
| CVisualChannelInfo | What a visual channel is. The strings stay valid for the life of the port |
| CVisualEvent | One occurrence on an events channel |
| CVisualPort | Read access to the values and meters a processor publishes for its UI |
| CNativeParent | A native window to attach an editor to, owned by the host |
| CEditorSize | An editor size in logical pixels, with the backing scale factor that maps them to physical pixels (2.0 on a Retina display) |
| CEditorKeyEvent | A key the host offers to the editor before acting on it itself |
| CEditorAutomation | Optional automation surface of an editor, so tooling (the pulp control UI tools, tests) can see and drive any editor whatever draws it |
| CEditor | One editor instance in one native window |
| CHostActionRequest | One host action and its arguments |
| CEditorContext | What the host gives an editor |
| CEditorFactory | Builds a processor's editors |
| CEditorOwnerObserver | Implemented by an editor view that reads its plug-in instance (Processor, StateStore or other instance state) directly |
| CEditorUiInstance | |
| CEditorUiSource | Where the default scripted editor's document comes from |
| CFactoryProgramTable | |
| CGpuHostDecision | |
| CGraphRuntimeAudioEdgeProbe | |
| CGraphRuntimeCommandDecision | |
| CGraphRuntimeNodeProcessContext | |
| CGraphRuntimeCommandHandler | |
| CGraphRuntimeNodeBinding | |
| CGraphRuntimeSnapshot | Control-thread-built graph snapshot for GraphRuntimeExecutor |
| CInputPortSource | |
| CGraphRuntimeEventSink | |
| CGraphRuntimeExecutorStats | |
| CGraphRuntimeExecutorResult | |
| CGraphRuntimeBufferPool | Pre-allocated scratch buffers backing the routing process() path |
| CDelayRing | |
| CBoundNode | |
| CGraphRuntimeMidiScratch | Pre-allocated per-node MIDI buffers backing the routing path's event edges |
| CGraphRuntimeAutomationScratch | Pre-allocated scratch backing the routing path's parameter-automation edges |
| CPreparedStats | |
| CSparseAccum | |
| CGraphRuntimeExecutor | |
| CGraphRuntimeWorkerPool | Persistent fork-join worker pool for the levelized parallel graph executor |
| CSchedulingReceipt | |
| CHeadlessHost | Headless plugin host for testing and offline processing |
| CScopedHostParameterWrite | Marks the enclosing scope as a HOST-originated parameter write |
| CScopedProcessorParameterWrite | Marks the enclosing scope as a PROCESSOR-originated parameter write (a plug-in writing its own output parameters during process()) |
| CHostParameterEditBridge | Reports EDITOR parameter edits to the host, in protocol order, exactly once |
| CCallbacks | Protocol callbacks, in the order they are invoked for a gesture: begin → value(one or more) → value → end |
| CHostQuirks | Always-on / host-gated defensive behaviors that the adapters consult |
| CHostQuirksMeta | Per-quirk validation status, parallel to HostQuirks |
| CQuirkFilter | Selection of validation tiers a HostQuirks instance may keep |
| CResolvedQuirkPolicy | The runtime-resolved base filter together with its source |
| CQuirkFieldStatus | One row of resolved quirk state, for diagnostics (pulp doctor) |
| CHostVersion | Semver-ish host version |
| CHostInfo | Combined accessor: detect both type and version in one call |
| CNativeCoreProcessor | Owns a native DSP core (via the C ABI vtable) and exposes it as a Processor |
| CNoteName | One named note |
| COfflineRenderConfig | Prepare-time configuration for deterministic offline rendering |
| COfflineMidiEvent | |
| COfflineParameterEvent | |
| COfflineRenderOptions | |
| COfflineRenderStats | |
| COfflineRenderResult | |
| COfflineRenderHost | General-purpose offline renderer over a ProcessorFactory |
| COfflineSampleBouncePolicy | Offline/control-thread bounce policy for turning a rendered processor span into sampler-owned audio |
| COfflineSampleBounceRequest | |
| COfflineSampleBounceResult | |
| COfflineSampleBounce | Control/background-thread helper over OfflineRenderHost |
| COfflineSampleSlotBounceResult | |
| COfflineSampleSlotBounce | Control/background-thread adapter from OfflineSampleBounce into SampleSlotBank publication |
| CPanicCapabilities | What a panic request can do in the current host |
| CPanicOutcome | What service_panic() did |
| CPanicState | Lock-free panic request and output-note state for one Processor |
| CParamGroupProjection | Validated, registration-ordered projection of StateStore parameter groups |
| CEntry | |
| CControlRateParamSmoother | |
| CPlaybackContextProjectionOptions | Format-layer metadata that is intentionally absent from the engine-owned transport snapshot |
| CViewSize | Editor size hints (in logical pixels) |
| CBusInfo | Audio bus description — for multi-bus plugins (sidechain, aux, etc.) |
| CBusLayoutConfiguration | One complete host-selectable channel configuration |
| CNodeCapabilities | Capability sidecar for the node ABI |
| CPluginDescriptor | Plugin metadata — declared once, immutable |
| CPrepareResourceLimits | Optional prepare-time resource caps supplied by a host or test harness |
| CPrepareResourceUsage | Processor-reported prepared resource usage estimate |
| CPrepareContext | |
| CProcessBlockFlags | |
| CScratchArenaView | |
| CPrepareScratch | Prepare-time scratch view |
| CBlockScratch | Block-local scratch view for realtime/offline processing |
| CBusBuffer | |
| CBusBufferSet | Fixed-capacity, non-owning set of block-local bus views |
| CProcessBusBufferInfo | Metadata that travels with a non-owning richer-surface process bus view |
| CProcessBusBufferView | Non-owning view of one richer-surface process bus |
| CProcessBusBufferSet | Non-owning span of richer-surface process buses for one direction |
| CProcessBuffersT | Additive richer-surface process-buffer view. It is intentionally non-owning |
| CEventDropCounters | |
| CAudioRateModulationView | Non-owning dense per-sample parameter-modulation lane |
| CEventBlock | Non-owning view of all sparse events visible to one process block |
| CProcessBlock | Additive block-scoped process contract |
| CProcessContext | Process context — passed every audio callback with transport state |
| CProcessor | |
| CBusesLayout | ── Opt-in DSP-state carry across a hot-reload (reload lane, item 1.6) ── On a hot-reload the new processor binds to the live StateStore (params + values preserved), but its DSP-internal state — delay lines, filter history, reverb tails, oscillator phase — starts COLD |
| CEditorPrewarm | What a scripted editor evaluates every time it opens and that does not depend on the instance: the text of the scripts it loads through WidgetBridge::load_script() (its ScriptedUiSession's script file, a design or help script loaded after the mount) and the inputs it passes to __pulpRuntimeImport__(text, 'materialized-browser'), byte-identical |
| CSettingsSection | A custom settings tab this plugin contributes to the host's Settings UI |
| CParamEventsOptOutMonitor | Records, for one adapter, whether an opted-out processor read param_events(), and logs it once |
| CProcessorBlockAdapterScratch | Caller-owned fallback storage for process_processor_block() |
| CProcessorNode | Runs a real pulp::format::Processor as a node inside the routed graph |
| CProcessorNodeInstance | Retained, self-contained lifetime for an authored in-process graph node |
| CProjectionResult | |
| CPulpsetEvent | One timed steer in a .pulpset |
| CPulpset | A parsed .pulpset — events sorted by sample offset |
| CPulpsetRender | Rendered stereo result of a replay |
| CPluginRegistration | One registered plugin |
| CSettingsPanelCallbacks | Callbacks from SettingsPanel to the standalone host |
| CSettingsPanel | Audio/MIDI Settings panel with two tabs |
| CSpectralFrameView | Borrowed only during Stage::process() |
| CSpectralFrameStage | Stage instances are owned by the adapter |
| CSpectralFrameProcessor | One audio graph node containing an ordered chain of typed frame stages |
| CStandaloneConfig | |
| CStandaloneApp | |
| CStandaloneControlHost | Optional host-side control composition for one ordinary StandaloneApp |
| CStandaloneControlHostCreation | |
| CStateRestoreGate | |
| CRenderLock | Audio-thread pin |
| CRestoreLock | Control-thread hold |
| CTestSignalConfig | |
| CTestSignalSource | Generates test audio for the standalone host: sine tone or file playback |
| CTransportValidity | Compact validity mask for the transport values carried by ProcessContext |
| CTransportQuantizeRequest | |
| CTransportQuantizerBlock | |
| CTransportQuantizeResult | |
| CTransportQuantizer | |
| CBlockPlan | |
| CReportEntry | One entry in the validation report (matches report schema) |
| CValidationRunOptions | Options for a validation run |
| CValidationHarness | Deterministic validation harness |
| CValueChannelVisualPort | Reads a ValueChannelSet through the VisualPort contract |
| CViewBridge | |
| COptions | |
| Ngpu_audio | |
| CGpuAudioCapabilityReport | Backend-neutral, allocation-free capability snapshot for installed SDK consumers |
| CGpuAudioCapabilityValidation | |
| CGpuAudioStatusValidation | |
| CGpuAudioNodeDescriptor | Declared, fixed scheduling properties of a GPU audio node |
| CGpuAudioNode | A unit of audio work the transport schedules onto a non-real-time worker |
| CGpuAudioProgramDescriptor | Backend-neutral metadata for a typed program prepared for a fixed audio stream |
| CGpuAudioProgramValidation | |
| CGpuAudioProviderPool | Host-owned cache of prepared GPU-audio providers that survive a node's release, so the next prepare() of a node with the same program skips device, pipeline and resident-weight creation |
| CConfig | |
| CStats | |
| CGpuAudioStatus | Versioned, allocation-free status shared by native hosts and UI adapters |
| CGpuAudioTransport | Fixed-latency real-time transport between the audio thread and a non-RT worker that runs a GpuAudioNode |
| CConfig | |
| CStats | |
| CDeliverySnapshot | Selected output for prepared process() calls, not worker completions or GPU admissions |
| CGpuConvolutionReverbConfig | Configuration for the opt-in GPU realization of Forge's stereo convolution reverb |
| CGpuConvolutionReverbLaneReport | Per-lane evidence |
| CGpuConvolutionReverbReport | |
| CGpuConvolutionReverb | Optional, control-parity GPU route for the two-channel Forge convolution reverb |
| CGpuConvolverTraceConfig | Opt-in diagnostics for the shared-I/O path |
| CGpuConvolverStagedBreaker | Circuit breaker for the staged GPU readback |
| CGpuConvolver | First real GPU audio node: FFT-based (overlap-add) convolution of the input with a fixed impulse response, computed on the GPU via render::GpuCompute on the transport's non-RT worker |
| CGpuMultiConvolver | Massive multi-IR ("multi-room") convolution: convolves one mono input against MANY distinct impulse responses at once and pans the results into a stereo field — the whole bank in ONE batched GPU submit per block |
| CGpuNeuralCpuKernel | One channel's CPU model step, supplied and owned by the caller |
| CGpuNeuralModelManifest | Provenance and compatibility metadata for a model artifact |
| CGpuNeuralModelShape | The family's state shape: one layer per family (a single scalar TCN layer, one LSTM/GRU layer, one diagonal SSM) |
| CGpuNeuralModelRequest | |
| CGpuNeuralModelResult | |
| CGpuNeuralRealtimeNode | Architecture-neutral realtime neural node with a built-in CPU shadow |
| CShadowStatus | Allocation-free shadow diagnostics |
| CConfig | |
| CGpuSpectralFreeze | Phase-vocoder spectral freeze: capture one analysis frame and sustain it indefinitely with a SEAMLESS, evolving loop — no loop boundary, no click |
| CGpuSpectralMaskSession | |
| CConfig | |
| CCreateResult | |
| CResult | |
| CDiagnostics | |
| CGpuSpectralMorph | Spectral morph: capture two spectra (A and B) and render a blend at position t ∈ [0,1] — the signature "morph between two sounds" effect |
| CGpuStft | GPU short-time Fourier transform primitive (spectral toolkit) |
| CGpuWaveNetLayerDescriptor | |
| CGpuWaveNetDescriptor | |
| CGpuWaveNetValidation | |
| CGpuWaveNetBlockResult | |
| CGpuWaveNetSession | A prepared, one-stream shared-memory WaveNet session |
| CConfig | |
| CCreateResult | |
| CGpuWaveNetTraceConfig | Experimental stamped WaveNet bridge |
| CGpuWaveNetRealtimeNode | |
| CConfig | |
| CSpectralStack | A stack of N captured spectral "moments" (layers) that can be sustained and morphed |
| CCpuSpectralStack | CPU reference + always-available fallback |
| CGpuSpectralStack | GPU-resident engine: the captured layer spectra live on the GPU and every hop runs advance + smear + weighted-sum + one inverse FFT on the device, reading back only the single synthesized frame |
| CSpectralFreezeControls | Per-hop control values handed to the framer (read on whatever thread drives the framer — the audio thread for the CPU engine, the GPU worker for the GPU engine) |
| CSpectralFreezeFramer | STFT freeze framer: turns an arbitrary-length input stream into hop-spaced analysis frames, drives a SpectralStack (capture on a Freeze rising edge, render every hop), and overlap-adds the synthesized frames back into an arbitrary-length output stream |
| CWebGpuConvolver | Submit/collect FFT convolver for a single-threaded event loop |
| Ngraph | |
| CGraphRuntimeNodeSlots | |
| CGraphRuntimeBufferAssignment | |
| CGraphRuntimeLevelization | |
| CGraphRuntimeLimits | |
| CGraphRuntimeNodeSpec | |
| CGraphRuntimeAutomationSpec | |
| CGraphRuntimeConnectionSpec | |
| CGraphRuntimeNodePlan | |
| CGraphRuntimeConnectionPlan | |
| CGraphRuntimePlan | |
| CGraphRuntimePlanError | |
| CGraphRuntimePlanResult | |
| CGraphRuntimeProbeSample | |
| CGraphRuntimeProbe | |
| CGraphCommandTiming | |
| CGraphCommand | |
| CGraphTimedCommand | |
| CGraphEvent | |
| CGraphMidiOutputEvent | |
| CGraphRuntimeQueueStats | |
| CGraphRuntimeQueues | Fixed-capacity graph command/event queues for realtime graph runtimes |
| CSpectralResult | |
| CSpectralFrameContract | Versioned, canonical identity carried by every routed spectral batch |
| CSpectralIdentity | Profile-one indexed channels: symmetric float Hann, local-window phase, forward scale one, inverse 1/N and full-overlap startup |
| CQualifiedSpectralStage | Closed catalog value |
| CSpectralFrameStamp | |
| CSpectralFrameReadView | |
| CSpectralFrameBatchView | Snapshot-owned payload and descriptors; callback borrows never own storage |
| Nhost | Bounded event contracts shared by host ingress and graph-authored nodes |
| Ndetail | |
| CClapIdentityAccess | |
| Nforge_lofi | |
| CAnalogVcfInstance | |
| CAnalogVcfIdentity | |
| CDelayInstance | |
| CFilterInstance | |
| CWaveshaperInstance | |
| CDryWetInstance | |
| CNoiseInstance | |
| CBitcrushInstance | |
| CTrimInstance | |
| CPingPongInstance | |
| CReverbInstance | |
| CCompressorInstance | |
| CGateInstance | |
| CLfoInstance | |
| CEnvFollowerInstance | |
| CFilterCvInstance | |
| CDelayCvInstance | |
| CAutoPanInstance | |
| CWidthInstance | |
| CPhaserInstance | |
| Ncharacter_delay | |
| CCharacterDelayInstance | |
| Ndistortion | |
| CDistortionInstance | |
| Ndynamics | |
| Ntrue_peak | |
| CInstance | |
| Nvca | |
| CInstance | |
| Nfet | |
| CInstance | |
| Ndiode | |
| CInstance | |
| CFeedforwardCompressorInstance | |
| Nmodulation | |
| Nchorus | |
| CInstance | |
| Nphaser | |
| CInstance | |
| Nvibrato | |
| Ndelay_line | |
| CInstance | |
| Nphase | |
| CInstance | |
| Nunivibe | |
| CInstance | |
| Neurorack | |
| CAttenuverterInstance | |
| CSlewInstance | |
| CClockDividerInstance | |
| CSampleHoldInstance | |
| Nforge_fdn | |
| CReverbInstance | |
| Nfuzz | |
| CInstance | |
| Nforge_modulation | |
| CModLfoInstance | |
| CModLpgInstance | |
| CModSlewInstance | |
| CModTransientInstance | |
| CModEnvInstance | |
| Nmultiband | |
| CInstance | |
| Npitch | |
| Nwhammy | |
| CInstance | |
| Nharmony | |
| CInstance | |
| Nsaturator | |
| CSaturatorInstance | |
| Nsequencing | |
| Nstage_seq | |
| CStage | One stage of the composed pattern — the realization payload |
| CInstance | |
| Ncartesian | |
| CInstance | |
| Nrungler | |
| CInstance | |
| Nquantize | |
| CInstance | |
| Ngate_logic | |
| CInstance | |
| Nprob_gate | |
| CInstance | |
| Nsidechain | |
| CInstance | |
| Nspace | |
| Nconvolution | |
| CImpulseResponse | |
| CIrPolicy | |
| CInstance | |
| Nnonlin_ambience | |
| CInstance | |
| Ncabinet | |
| CInstance | |
| Nsynthesis | |
| Nadditive | |
| CInstance | |
| Nvocoder | |
| CInstance | |
| Ncyclic | |
| CInstance | |
| Ngranular | |
| CInstance | |
| Ntape | |
| CCurveRange | The EQ curves an archetype's front panel exposes, as the inclusive [min, max] of the stepped kEqCurve parameter |
| CTapeMachineInstance | |
| Nwavetable | |
| CInstance | |
| CAnticipationEligibility | |
| CAnticipationLane | |
| CAnticipationBoundary | |
| CAnticipationPartition | |
| CAnticipationSubgraph | |
| COutput | |
| CAudioRouteInfo | |
| CAudioRouteCatalog | Control-thread source catalog supplied by a Pulp host (standalone, Forge, or another graph host) |
| CMutableAudioRouteCatalog | Small host-side implementation for standalone/Forge hosts |
| CCancelToken | Shared cancel flag |
| CBackgroundScanner | |
| CBakedPlan | |
| CNode | |
| CConn | |
| CBakedTrust | |
| CBakedCustomParamBinding | |
| CLowerResult | |
| CLowerabilityProof | |
| CCustomNodeLifecycle | |
| CBakedCustomNodeBinding | |
| CParamInjector | |
| CBakedGraphProcessor | |
| CBakedTypeRegistration | |
| CBakedTypeRegistry | |
| CBakedPlanLoadResult | |
| CBakePlanResult | |
| CBoundedDelayDescriptor | |
| CBoundedDelayRegistration | |
| CCrossfadePluginSlot | |
| CCustomNodeDiagnosticHandle | |
| CCustomNodeDiagnosticResult | |
| CCustomNodeDiagnosticsDescriptor | |
| CCustomNodeEventBlock | The events visible to one Custom node for one block |
| CBakedParamView | |
| CCustomNodeBakedParam | |
| CCustomNodeType | |
| CSampleKernelConfig | |
| CPreparedSampleKernelConfig | |
| CSampleKernelPrepareContext | |
| CSampleFrameContext | |
| CSampleKernelMetadata | |
| CSampleKernelDescriptor | |
| CCustomNodeTypeMetadata | |
| CForgeCatalogExportRealization | One actually constructed realization |
| CForgeCatalogExportNode | One machine-readable catalog family before JSON serialization |
| CForgeSampleRegionV1 | Exact v1 authoring routes |
| CForgeAuditFinding | |
| CForgeParamChoice | One named state of a stepped parameter |
| CForgeAxisValue | One value of a compile-time realization axis |
| CForgeParamDescriptor | |
| CForgeRealizationAxis | A compile-time construction axis — a choice made when the node is built rather than automated afterwards |
| CForgeRealizationSetting | One axis/value selection used to construct a concrete realization |
| CForgeRealization | One concrete realization: the exact type_id a graph names, plus the axis settings that produced it |
| CForgeNodeDescriptor | |
| CHostEventRecord | One immutable host event in the graph's epoch-local sample domain |
| CHostEventIngress | Fixed-capacity host ingress staging area |
| CGraphAuthoredEvent | |
| CGraphEventCounters | |
| CGraphAuthoredEventLane | Explicit producer/consumer phases for a bounded, single-producer event lane |
| CPortIdentityAlias | |
| CPortIdentityIssue | |
| CPortIdentityReport | |
| CPortIdentityDiff | |
| CPortIdentityUndo | |
| CGraphLoadOptions | |
| CGraphSerializer | |
| CSaveResult | |
| CLoadResult | |
| CGraphTimingDeclaration | |
| CGraphTimingMeasurements | |
| CGraphTimingEvidence | |
| CScanResult | |
| CIsolatedPluginScanner | |
| CVst3NativeHandle | |
| CAudioUnitNativeHandle | |
| CAudioUnitV3NativeHandle | |
| CClapNativeHandle | |
| CLv2NativeHandle | |
| CNativeHandleVisitor | |
| CGeneratedDeviceAdmission | |
| CNodePackEntry | |
| CNodePackResource | |
| CNodePackRuntimeRequirements | |
| CNodePackManifest | |
| CNodePackTrust | |
| CNodePackHostPolicy | |
| CNodePackLoadResult | |
| CVerifiedNodePackBinary | |
| CNodePackVerifyResult | |
| COfflineSignalGraphConfig | Prepare-time configuration for an offline SignalGraph render |
| COfflineSignalGraphOptions | Per-render inputs |
| COfflineSignalGraphResult | Result of an offline render |
| COfflineSignalGraphHost | Renders a SignalGraph offline at a fixed block size, using only the public SignalGraph API |
| CPluginTypeIdentity | CLAP-only type identity. Exact UTF-8 bytes; no name, path or normalization |
| CPluginArtifactProvenance | Executable-byte observation, not a portable release identity or signature |
| CPluginIdentityEvidence | Immutable owned evidence |
| CCanonicalPluginIdentity | |
| CPluginSelection | |
| CPluginResolvedIdentity | |
| CParamFlags | |
| CHostParamInfo | |
| CPluginSlot | |
| CHostedEditor | |
| CPluginLoadResult | Exactly one loaded slot or typed refusal. A successful slot owns its receipt |
| CProcessorTypeKey | |
| CProcessorRestoreDescriptor | Application-owned, exact-version registration |
| CProcessorRestoreRecord | Already decoded two-part state |
| CRestoredProcessor | |
| CProcessorRestoreResult | |
| CProcessorRestoreRegistry | Control-thread building block for hosts restoring a set of Processor nodes |
| CProcessorSignalGraphBinding | Lifetime-bound access from a Processor instance to the SignalGraph it owns |
| CLease | |
| CSampleRegionPromotedParameter | |
| CSampleRegionDefinition | |
| CSampleRegionDescriptor | |
| CSampleRegionResult | |
| CSampleRegionParameterContractEntry | |
| CSampleRegionParameterContract | |
| CSampleRegionParameterBinding | |
| CSampleRegionParameterOwner | |
| CPreparedSampleKernelBinding | |
| CPreparedSampleRegionTransfer | |
| CPreparedSampleRegionOperation | |
| CPreparedSampleRegionPlan | |
| CSampleRegionPlanResult | |
| CSampleRegionConnection | |
| CSampleRegionKernelNode | |
| CSampleRegionKernelRegistryView | |
| CSampleRegionLimits | |
| CSampleRegionCandidate | |
| CSampleRegionResourceStats | |
| CSampleRegionProof | |
| CSampleRegionGraphProof | |
| CSampleRegionParserShape | |
| CSampleRegionParserProof | |
| CSampleRegionStateKey | |
| CSampleRegionStateCell | |
| CSampleRegionExecutionDomain | |
| CAdmission | |
| CSampleRegionStateBank | |
| CSampleRegionRuntimeReceipt | |
| CPreparedSampleRegion | |
| CBlacklistEntry | |
| CScanBlacklist | |
| CScanCacheEntry | |
| CHostScanCache | |
| CPluginInfo | |
| CScanOptions | |
| CScanReport | |
| CPluginScanner | |
| CGraphAuthoringReceipt | |
| CConnection | |
| CSignalGraphRouteCommand | One typed mutation accepted by the host's canonical graph authority |
| CSignalGraphRouteResult | |
| CSignalGraphControlAuthority | The sole host-side authority for live graph modulation-route lifecycle |
| CSnapshotParameterIngressPasskey | Passkey authorizing exact-generation parameter-event injection into a pinned ExecutionSnapshot |
| CSignalGraphExecutionStatus | |
| CConnectionClass | |
| CExecutorTopologyValidation | |
| CPluginRoutingScratch | |
| CPluginBindingContext | |
| CPendingParameterEventSequences | |
| CParameterEventInjectionBinding | |
| CCustomBindingContext | |
| CSignalGraphExecutorRouting | |
| CExecutorSnapshotBinders | |
| CSpectralResolver | |
| CPortHandle | |
| CGraphResult | |
| CRetainedHistoryPolicy | |
| CNodeLiveSwapPolicy | |
| CLiveSwapDiagnostics | |
| CGraphNode | |
| CExactParameterNodeClaimPasskey | Passkey authorizing exact-parameter-event node claims on a prepared edit |
| CSignalGraph | |
| CGraphLimits | |
| CGeneratedGraphValidation | |
| CPreparedStats | |
| CPreparedNodeLatency | |
| CPreparedConnectionDelay | |
| CPreparedLatencySnapshot | |
| CRuntimeBudgetReport | |
| CPluginCatalogToken | |
| CNodeLoadReport | |
| CEdgeProbeIdentity | |
| CExecutionSnapshot | Strong, typed handle to one exact compiled SignalGraph generation |
| CPreparedTopologyEdit | |
| CLiveSwapAdmission | |
| CSubgraphNodeSpec | |
| CSubgraphEdgeSpec | |
| CSubgraphPortSpec | |
| CSubgraphParameterSpec | |
| CSubgraphChildSpec | |
| CSubgraphTemplate | |
| CSubgraphState | |
| CSubgraphParameterBounds | |
| CSubgraphInstance | |
| CSubgraphExpansionResult | |
| CSpectralInputPort | |
| CSpectralOutputPort | |
| CSpectralAnalysisPorts | |
| CSpectralStagePorts | |
| CSpectralSynthesisPorts | |
| CBuiltInDeviceDescriptor | One instantiable Pulp-owned device |
| CTimelineDeviceGraphRoute | One phase-1 track's lowering into the desktop SignalGraph adapter |
| CTimelineTrackGraphRoute | |
| CTimelineGraphBindingConfig | |
| CTimelineGraphAdmission | Structured admission result |
| CTimelineGraphProcessResult | |
| CTimelineGraphPlaybackBinding | Desktop adapter that lowers phase-1 timeline tracks into stable SignalGraph nodes |
| CTimelineDeviceFreeGraph | |
| CTimelineOfflineRenderConfig | Prepare-time limits |
| CTimelineOfflineRenderOptions | One render request over a half-open tick region [start_tick, end_tick) |
| CTimelineOfflineRenderResult | Result of a one-shot render. audio is populated only when code == Ok |
| CTriggerPayload | |
| CTriggerRecord | |
| CTriggerContext | |
| CTriggerDetectorLane | |
| CTriggerProducerConfig | |
| CTriggerEnvelopeConfig | |
| CTriggerAudioConfig | |
| CTriggerEdge | |
| CTriggerCounters | |
| CTriggerResourceReport | |
| CPreparedTriggerPlan | |
| CTriggerPreparation | |
| CVoicePortKey | |
| CVoiceIdentityKey | Canonical authored identity for one template/bank/slot/path target |
| CVoiceIdentityResult | |
| CGraphRuntimeConnectionPlan | |
| CGraphRuntimeConnectionSpec | |
| CGraphRuntimeLimits | |
| CGraphRuntimeNodePlan | |
| CGraphRuntimeNodeSpec | |
| CGraphRuntimePlan | |
| CGraphRuntimePlanError | |
| CGraphRuntimePlanResult | |
| CGraphCommand | |
| CGraphCommandTiming | |
| CGraphEvent | |
| CGraphMidiOutputEvent | |
| CGraphRuntimeQueueStats | |
| CGraphTimedCommand | |
| CQualifiedSpectralStage | Closed catalog value |
| CSpectralIdentity | Profile-one indexed channels: symmetric float Hann, local-window phase, forward scale one, inverse 1/N and full-overlap startup |
| Nmidi | |
| Nrouting_detail | |
| CHeldNoteLedger | |
| CArpeggiatorGate | |
| CArpeggiatorSpec | |
| CArpeggiatorBlock | Block timing for one sample-accurate arpeggiator call |
| CArpeggiatorCapacityContract | |
| CArpeggiator | Fixed-capacity, sample-accurate MIDI arpeggiator |
| CBleMidiPeripheral | One BLE peripheral that advertises the BLE-MIDI service |
| CBleMidiCentral | Cross-platform BLE MIDI central |
| CBleMidiUuids | The well-known service / characteristic UUIDs (16-byte big-endian) |
| CBleMidiPacketDecoder | Stateful decoder |
| CBleMidiPortRegistry | Singleton bridge between BLE-MIDI centrals and the platform MidiSystem |
| CMidiBuffer | Collection of timestamped MIDI events within a single audio buffer period |
| CSysexPayload | |
| CSysexEvent | |
| CChordMemorySpec | |
| CChordMemory | Bounded chord memory: capture a chord once, then play it from single notes |
| CControllerMapRule | |
| CControllerMapper | |
| CScaleAwareMpeSpec | |
| CScaleAwareMpePitch | |
| CMidiPortInfo | |
| CMidiInput | |
| CMidiOutput | |
| CMidiSystem | |
| CHumanizeSpec | Seeded timing and velocity jitter over note attacks |
| CHumanize | MaximumPendingAttacks bounds how many attacks can sit in the jitter window at once |
| CMidiKeyboardState | Tracks the state of all 128 MIDI keys across 16 channels |
| CLatchSpec | |
| CLatch | Bounded note-retention kernel over a MIDI event stream |
| CMidiEvent | Timestamped MIDI event combining a choc::midi::ShortMessage with timing info |
| CTimestampedShortMessage | Timestamped MIDI event in the collector queue |
| CMidiMessageCollectorTelemetry | |
| CMidiMessageCollector | |
| CMUID | MIDI-CI MUID (Message Unique Identifier) — 28-bit random ID |
| CCiDeviceInfo | CI device identity (from discovery) |
| CProfileId | CI Profile identifier (5 bytes) |
| CProfileState | CI Profile state |
| CFunctionBlockId | UMP Function Block identifier (MIDI 2.0 §A) — a Function Block is a logical grouping of UMP groups that share a single set of CI / Profile state |
| CFunctionBlockInfo | Description of a single Function Block as advertised by an endpoint |
| CProfileDetails | Profile Details Inquiry/Reply payload (CI 1.2 §7.6) — per-profile metadata the responder publishes when asked for "more about profile X" |
| CCiDiscovery | MIDI-CI Discovery manager — handles CI message exchange |
| CPeChunk | A single PE chunk, after Mcoded7 decode of header + payload |
| CPeReassembler | Reassemble a stream of incoming PeChunks for the same request_id |
| CPeSubscription | One active subscription state — owned by PeSubscriptionManager |
| CPeSubscriptionManager | Authoritative subscription registry on the responder side |
| CMidiControlBus | |
| CTimedMidiEvent | |
| CMidiTrack | |
| CMidiFileData | |
| CTimestampedMidiEvent | A MIDI event with timestamp (in seconds or samples) |
| CMidiMessageSequence | Ordered sequence of MIDI events with editing operations |
| CMockMidiSystem | |
| CMonotonicMidiClock | Monotonic timestamp source for MIDI input events, measured in seconds from a base captured when the port opened |
| CMpeExpressionEvent | A single per-note expression event |
| CMpeBuffer | A time-ordered list of per-note expression events for one block |
| CMpeMessageList | Fixed-capacity, allocation-free list of events returned by the builders |
| CMpeSynthVoice | Abstract base for a single MPE voice |
| CMpeVoiceAllocatorTelemetry | |
| CMpeVoiceAllocatorRuntimeBudgetReport | |
| CMpeGlideDetector | Glide/legato detector — observes MPE note-on events and reports when a new note on the same channel overlaps an existing held note |
| CMpeVoiceAllocator | Routes MPE expression events to a pool of voices of type Voice (which must derive from MpeSynthVoice) |
| CMpeNoteState | Per-note state maintained by MpeVoiceTracker |
| CMpeVoiceTracker | Tracks MPE voice state across channels |
| CZoneState | |
| CNoteDelaySpec | MIDI note delay / echo |
| CNoteDelay | MaximumHeldSources bounds how many authored notes can have armed echoes at once |
| CNoteRepeatSpec | Clock-divided note repeat / retrigger |
| CNoteRepeat | |
| CNoteLengthSpec | |
| CNoteLengthShaper | |
| CMonophonicSpec | |
| CMonophonicPitchState | |
| CBasicMonophonicNoteSelector | |
| CPanicScope | Which channels and which message kinds a panic covers |
| CPortListDiff | Ports that appeared and ports that went away between two snapshots |
| CPortListTracker | Remembers the last snapshot and reports what changed since |
| CPortChangePoller | Calls on_change from a background thread whenever the combined input and output list changes |
| CRawMidiParserState | |
| CChannelRouteSpec | |
| CChannelRouter | |
| CNoteRangeSpec | |
| CNoteRangeFilter | |
| CKeyboardSplitSpec | |
| CKeyboardSplit | |
| CRpnParser | Parses RPN (Registered Parameter Number) and NRPN (Non-Registered Parameter Number) messages from a stream of MIDI CC events |
| CRunningStatusParser | |
| CStepPlayerStep | The authored data at one lane and step coordinate |
| CStepPlayerLaneSpec | |
| CStepPlayerBlock | Block timing for one sample-accurate step-player call |
| CStepPlayerCapacityContract | |
| CStepPlayerCoordinate | A lane's authored coordinate at one grid tick |
| CStepPlayer | Fixed-capacity, sample-accurate multi-lane linear step player |
| CSpec | |
| CStrumSpec | Spread a near-simultaneous cluster of notes across time |
| CStrum | |
| CSynthesiserNote | Per-note metadata maintained by the Synthesiser when a voice is activated |
| CSynthesiserTelemetry | |
| CSynthesiserRuntimeBudgetReport | |
| CSynthesiserVoice | Abstract base for one synth voice |
| CSynthesiserNoteOnPolicy | Constant note-on metadata for MIDI-buffer dispatch |
| CSynthesiser | Polyphonic synth that routes plain-MIDI events into a pool of Voice instances |
| CSysexAccumulator | |
| CSysexChunkAssembler | |
| CTuningQueryResult | |
| CTuningNoteResult | |
| CTuningStatus | |
| CTuningProvider | |
| CEqualTemperamentTuningProvider | |
| CUmpPacket | |
| CMpeZone | |
| CMpeConfig | |
| CUmpEvent | One UMP packet with a block-relative sample offset |
| CUmpBuffer | A time-ordered list of UMP events for one audio block |
| CMidi2ProgramChange | Decoded fields of a MIDI 2.0 Channel Voice Program Change (status 0xC) |
| CUmpEndpointDirection | Direction the endpoint exposes |
| CUmpEndpointInfo | Static description of an endpoint discovered on the system or registered virtually |
| CUmpEndpoint | Polymorphic endpoint handle |
| CUmpSessionConfig | Options for creating a session |
| CUmpSession | |
| CUmpSysex7Reassembler | Reassembler state machine for UMP Type-0x3 sysex7 packet streams |
| CVirtualUmpEndpointConfig | Configuration for a newly-registered virtual endpoint |
| CVirtualUmpEndpoint | |
| CMidiUtilityContract | |
| CMidiUtilityProcessReport | |
| Ninterchange | |
| Ndetail | |
| CFormatRecord | |
| CConceptRecord | |
| CCensusLimits | Bounds on how much evidence one census retains |
| CConceptCensus | Which interchange concepts a document uses, how often, and where |
| CExportArtifact | What one export produced |
| CExportArtifacts | |
| CExportError | |
| CExportOptions | |
| CExportPlan | A document measured against one format's capability table: what survives, and what it costs |
| CFormatBoundExportWriter | A format-bound byte writer that can only be invoked by run_export |
| CImportRow | |
| CExportRow | |
| CLossEntry | One concept a document uses that an export cannot carry intact |
| CLossManifest | Everything one export costs the document |
| Nmusic | |
| Ndetail | |
| CVoicingAccess | |
| CChordCompatibilityEntry | |
| CChordFormula | |
| CChord | |
| CDiatonicChord | |
| CRecognitionScore | |
| CChordRecognition | |
| CChordRecognitionList | |
| CPreparedMarkovModel | |
| CBinaryPattern | |
| CPatternResult | |
| CEuclideanPatternRecipe | |
| CPatternWalker | |
| CMutationChance | |
| CShiftRegisterResult | |
| CPatternEvent | One uniquely identified onset in a development pattern |
| CDevelopmentPattern | Fixed-capacity, onset-ordered collection used by development operations |
| CPatternDevelopmentResult | Pattern-development output paired with an explicit result code |
| CDensitySelection | Parameters for deterministic density selection |
| CRegionalFillSelection | Parameters for deterministic replacement within a half-open region |
| CPatternMorphSelection | Parameters for deterministic interpolation between two patterns |
| CPitchClassSet | |
| CScaleCompatibilityEntry | |
| CScale | |
| CRhythmDrawCoordinate | |
| CRhythmRelationshipConfig | |
| CRhythmRelationshipResult | |
| CSpelledPitchClass | |
| CSpelledChord | |
| CMidiRange | |
| CVoicingConstraints | |
| CVoicing | |
| Nosc | |
| CTimeTag | OSC timetag — NTP timestamp (seconds since 1900-01-01) |
| CBundleElement | Bundle element — either a message or a nested bundle |
| CBundle | OSC Bundle — contains a timetag and a list of elements |
| CColorRgba | 32-bit RGBA color — the OSC 1.0 optional 'r' type tag |
| CMessage | |
| CSender | |
| CReceiverRoute | |
| CReceiverOptions | |
| CReceiver | |
| COscChannelOptions | |
| COscChannel | |
| COscMapScale | The incoming value range an OSC surface sends, and the normalized [0, 1] window it drives |
| COscParameterMap | |
| Nplatform | Device capability vocabulary: one tier ladder, one thermal ladder, and the projection from observed inputs onto them |
| CProcessResult | Result of a completed child process |
| CProcessOptions | Options for child process execution |
| CChildProcessInputChannel | Move-only parent endpoint of the child's inherited standard-input channel |
| CChildProcess | Cross-platform child process with timeout, cancellation, and line-by-line output callbacks |
| CClipboard | |
| CAndroidBridge | |
| CDBus | |
| CPortalResult | Reply value for an xdg-desktop-portal request: the response code (0 = success, 1 = user cancelled, 2 = other) plus any returned URIs |
| CReader | Reads basic + container values out of an incoming message's argument list |
| CWriter | Appends values to an outgoing message (reply or signal) |
| CContainer | A nested container being built |
| CCallContext | Context for one incoming method call against a registered object |
| CDeviceCapabilityInputs | What a shell observed about the device it is running on |
| CSafeAreaInsets | Safe-area insets in CSS-pixel space (already divided by content_scale) |
| CKeyboardInset | Soft-keyboard inset (mobile only) |
| CDisplayInfo | Logical display geometry |
| CEnvironmentChange | Bitmask of fields that changed in the snapshot delivered to a listener |
| CEnvironmentState | Snapshot of the full environment state |
| CEnvironment | In-process notifier |
| CToken | RAII subscription. Drop to unsubscribe |
| CFileFilter | |
| CFileDialog | |
| CBackend | |
| CPermissionsOverride | Test helper: scope-guarded override |
| CPopupMenu | |
| CItem | |
| CProgressEvent | A structured progress event parsed from a PROGRESS:TYPE:PAYLOAD line |
| CProgressParser | Parses lines matching the PROGRESS:TYPE:PAYLOAD protocol and fires a callback for each match |
| CSpecialDirInputs | Everything the resolver may read, so every platform's layout can be computed (and tested) on any host |
| Nrender | |
| CAtlasInfo | A value-snapshot of one texture atlas's state, taken at a known point |
| CAtlasInventory | A read-only collection of atlas snapshots for the inspector |
| CDirtyTracker | Tracks rectangular regions that need repainting |
| CRect | |
| CDecodedMesh | Decoded mesh geometry from DRACO-compressed data |
| CDracoAttributeIds | Draco attribute unique IDs from a glTF KHR_draco_mesh_compression attributes map |
| CGpuDeviceFeatures | Optional device features that change what a format can do |
| CGpuFormatSupport | What one format supports on a device |
| CGpuDeviceFacts | The facts pick_tier() reads. A test can build one by hand |
| CGpuDeviceCapabilities | Rendering capabilities of the shared device |
| CGpuCompute | GPU compute pipeline for non-rendering workloads (e.g |
| CWavenetLayerArraySpec | One WaveNet layer-array's static shape |
| CReadbackResult | |
| CAsyncStats | Counters for the async path, incremented where the work actually happens: submits at the queue submit, map_resolves when the GPU map callback fires, expired/failed when a request completes with that status |
| CCapabilityReport | Runtime GPU capability/limit report for the compute device |
| CDeviceSharingReport | |
| CBenchmarkResult | |
| CGpuDiagnosticsStats | Counters that separate "the sink was never called" from "the sink was called
but this build compiles the trace macros out" |
| CSkiaLogBridgeState | |
| CLogTextBudget | A thread-safe "first N" budget: admit() returns true for the first limit calls and false afterwards, counting both |
| CGpuError | |
| CGpuTextureDesc | |
| CGpuTexture | |
| CGpuBufferDesc | |
| CGpuBuffer | |
| CGpuSamplerDesc | |
| CGpuSampler | |
| CGpuShaderModule | A compiled WGSL module |
| CGpuVertexAttribute | |
| CGpuVertexBufferLayout | |
| CGpuColorTargetDesc | |
| CGpuDepthStateDesc | |
| CGpuRenderPipelineDesc | |
| CGpuRenderPipeline | |
| CGpuComputePipelineDesc | |
| CGpuComputePipeline | |
| CGpuBinding | One entry of a bind group: a buffer range, a texture or a sampler |
| CGpuBindGroup | |
| CGpuTargetDesc | |
| CGpuPixels | Tightly packed pixels read back from a target, rows top to bottom |
| CGpuTarget | Offscreen color target (and optional depth) with CPU readback |
| CGpuDevice | Typed handle to the device a GpuSurface owns. Copies share it |
| CGpuColorAttachment | |
| CGpuRenderPassDesc | |
| CGpuRenderPass | An open render pass |
| CGpuComputePass | An open compute pass. Same rules as GpuRenderPass |
| CGpuSubmission | Completion of one submitted frame |
| CGpuFrame | One command encoder's worth of passes, submitted once |
| CDawnProcInstaller | A host-supplied installer for Dawn's process-global proc table |
| CGpuRenderTimeTracker | Thread-safe holder for the latest GPU render-time sample |
| CGpuFramesInFlight | Frames whose GPU work has been submitted but has not finished executing |
| CGpuStartupReport | Bring-up stage timings from GpuSurface::initialize() plus the two stages the owning host measures around it |
| CSwapchainResizeState | Decides when a presentable swapchain has to be (re)configured |
| CGpuSurface | Abstract GPU surface — a presentable rendering target backed by a native window/view |
| CAdapterInfo | |
| CConfig | |
| CX11NativeHandle | Typed X11 surface handle |
| CStartupTimings | Wall-clock milliseconds spent in each stage of initialize(), measured with a monotonic clock |
| CSwapchainStats | Swapchain configurations issued since initialize(), the first one included, their total wall-clock milliseconds, and whether the size has settled |
| CHeadlessSurface | One-call wrapper for the existing offscreen Dawn + Skia path (GpuSurface::create_dawn() + native_surface_handle=nullptr + SkiaSurface::create) |
| CConfig | |
| CRgba | |
| CDecodedTexture | Parsed texture data from a KTX2 container |
| CDisplayRateBoost | |
| CRenderLoop | |
| CPassStats | Statistics for a single render pass |
| CRenderPassManager | Frame-level render pass manager |
| CHardcodedCubeRenderConfig | |
| CScene3DRenderResult | |
| CSceneDataRenderConfig | |
| CRenderer3D | |
| CSdl3SurfaceInfo | |
| CGpuCacheBytes | GPU bytes held by a surface's Skia resource caches |
| CGpuIdleTrimSchedule | When a surface's idle trim runs |
| CSkiaSurface | Skia Graphite rendering surface |
| CConfig | |
| CTrimLevel | How much a GPU trim frees |
| CSkpCaptureResult | Outcome of a .skp capture attempt |
| CSkpFrameCapture | Records a single frame's draw ops into an SkPicture and serializes it to a .skp artifact |
| CAtlasPacker | Simple rectangle packer for atlas allocation |
| CRegion | |
| CImageAtlas | Image atlas — packs small images into a shared GPU texture |
| CEntry | |
| CGradientAtlas | Gradient atlas — caches evaluated gradient ramps as GPU textures |
| CEntry | |
| CGlyphAtlas | Glyph atlas — per-font-size glyph cache as GPU texture |
| CEntry | |
| CPathAtlas | Path atlas — caches rasterized vector paths (e.g., complex SVG icons) |
| CEntry | |
| CBufferPool | Buffer pool — reuses std::vector allocations in hot rendering paths |
| CWgslDiagnostic | |
| Nplayback | |
| CAudioRendererError | |
| CDecodedAudioAsset | |
| CDecodedAudioAssetPool | Immutable, ID-sorted ownership table prepared off the audio thread |
| CClipPlacementFadeSegment | One placement-fade ramp a flattened leaf sits under, in clip-relative frames |
| CClipPlacementFadeProgram | Every placement fade one flattened leaf sits under |
| CAudioClipRendererProgram | |
| CAudioTrackRendererProgram | |
| CArrangementAudioRenderer | Renders every arrangement-selected audio track in PlaybackProgram order |
| CArrangementAudioTrackRenderer | One stable SignalGraph-facing arrangement audio renderer |
| CTrackMixerTrackRenderer | Stable SignalGraph-facing post-device track mixer |
| CAudioRendererLimits | Shared compile and RT ceilings |
| CAutomationBlockEvent | |
| CAutomationCursorResult | |
| CAutomationSegmentView | Random-access, immutable segment storage used by the production cursor |
| CIterator | |
| CAutomationProgramView | The identity, exact tempo-map object, and immutable segments consumed by AutomationCursor |
| CAutomationCursor | Allocation-free renderer for one immutable AutomationProgram |
| CAutomationPlaybackLimits | Preparation and callback-work ceilings shared by document compilation and track automation rendering |
| CAutomationProgramInstanceToken | |
| CAutomationProgramError | |
| CAutomationProgramSegment | |
| CAutomationProgram | Immutable tick- and sample-domain form of one automation lane |
| CRecordedAutomationPoint | |
| CMaterializedAutomationCurve | |
| CAutomationRecorder | Captures parameter gestures into a bounded point stream |
| CBufferedContentSourceConfig | |
| CBufferedContentSource | |
| CStats | |
| CCaptureTrackConfig | |
| CCaptureEngineConfig | |
| CCaptureSession | |
| CCaptureTakeHandle | |
| CCapturedMidiEvent | |
| CCaptureCommand | |
| CCaptureEvent | |
| CCaptureEngineStats | |
| CCaptureEngine | Fixed-capacity input recorder |
| CChordPatternContent | Immutable authored settings for the deterministic chord-pattern compiler |
| CLaunchEvent | |
| CLaunchHandle | |
| CFollowActionEvent | |
| CFollowActionTimer | |
| CContentFragmentNote | One musical note emitted by a registered content compiler |
| CContentFragmentError | |
| CContentProgramFragment | Owned immutable note output from one off-realtime compile-hook invocation |
| CRegisteredContentCompileInput | Bounded input presented to a trusted compiler hook on the compile worker |
| CContentRendererRegistration | One content renderer's registration, reduced to the part the dirty set depends on: which content kind it renders, and which timeline context its compile hook reads beyond that content |
| CContextRegistrationError | |
| CCompileContextRegistry | The declaration side of the compile-context subscription contract |
| CCompileInvalidationIndex | Bundled reverse index for nested dependencies and compile-context readers |
| CCompileSliceBudget | |
| CCompileTask | |
| CCompileExecutor | |
| CDeferredCompileExecutor | |
| CWorkerCompileExecutor | |
| CDirtyTrackSet | |
| CEventCompensationShift | One event-injection point's prepared scheduling shift, counted in samples at the program's compiled sample rate |
| CEventCompensationResult | |
| CCompensatedReadSegment | One contiguous run of a compensated read window after an enabled loop has been applied to it |
| CCompensatedReadPlan | How a compensated read window resolves against an enabled loop |
| CMtcTimecode | |
| CMtcChaseUpdate | |
| CMtcChaser | Allocation-free MTC decoder |
| CExternalSyncOutputConfig | |
| CExternalSyncOutputResult | |
| CExternalSyncOutput | Stateless block projection from the musical transport to MIDI sync |
| CGeneratedEventSpan | A half-open span on the transport's non-looping clock |
| CGeneratedEvent | One value-owned generated event |
| CGeneratedEventDegradationLadder | |
| CGeneratedEventSourceConfig | |
| CGeneratedEventStageResult | |
| CGeneratedEventCommitResult | |
| CGeneratedEventPullResult | |
| CGeneratedEventSource | |
| CStats | |
| CMidiCaptureMaterializationConfig | |
| CMaterializedMidiCapture | |
| CNoteRenderResult | |
| CArrangementNoteRenderer | Arrangement-note scheduler for the engine transport-tick lane |
| COfflineStretchAlgorithmConfig | |
| COfflineStretchArtifactKey | |
| COfflineStretchArtifact | |
| COfflineStretchProvenance | |
| COfflineStretchError | |
| COfflineStretchLimits | |
| COfflineStretchArtifactCache | Control-thread-only bounded semantic artifact cache |
| COfflineStretchCompileJob | Control-thread-only resumable source-SRC-stretch-seal pipeline |
| CProgramError | |
| CProviderSelectorProgram | |
| CNoteProgramEvent | Immutable arrangement-note event lowered by the program compiler |
| CCompiledNoteModifier | One note's playback modifier, lowered with its draw key already folded from the content's authored seed and the note identity |
| CControllerProgramEvent | Immutable controller/expression value lowered by the program compiler |
| CTrackProgram | |
| CPlaybackProgram | |
| CPlaybackProgramStore | |
| CTrackCompilePolicy | |
| CCompileInvalidationInput | One committed document delta lowered through the compile-context registry |
| CProgramCompileRequest | |
| CCompileError | |
| CCompileTicket | |
| CCompilerStatus | |
| CPlaybackProgramCompiler | |
| CRendererProgramKey | |
| CProgramWireError | |
| CProgramWireHeader | The fixed prefix every payload starts with |
| CProgramWireSectionEntry | |
| CProgramWireProgramRecord | The whole-program scalars, including the tempo map's sample rate and the automation ceilings the adopting realm must render within |
| CProgramWireTempoPointRecord | The editable tempo points, not the compiled segments |
| CProgramWireTrackRecord | One track |
| CProgramWireIdRecord | |
| CProgramWireNoteEventRecord | This happens to hold the same fields in the same order as NoteProgramEvent, and that correspondence is coincidental and must not be relied on |
| CProgramWireNoteModifierRecord | |
| CProgramWireControllerRangeRecord | One track's range into the ControllerEvents section |
| CProgramWireControllerEventRecord | One ControllerProgramEvent, field by field — never cast between the two, for the reason given on ProgramWireNoteEventRecord |
| CProgramWireAutomationLaneRecord | instance_token is the producer's own AutomationProgram::instance_token() carried verbatim, because lane identity is not (lane_id, generation) alone |
| CProgramWireAutomationSegmentRecord | Deliberately not laid out like AutomationProgramSegment: this groups the three floats and puts interpolation last so the record packs to 48 bytes with one run of padding, where the program type interleaves them |
| CProgramWireView | A validated, zero-copy view over one encoded program generation |
| CProgramWireBytePin | A unique lease over immutable publication bytes |
| CProgramWireAdoptionResult | |
| CProgramWireLaneIdentity | |
| CProgramWireLaneState | One caller-provided fixed-capacity state slot |
| CProgramWireAutomationLaneOutput | |
| CProgramWireAutomationRenderResult | |
| CProgramWireAutomationConsumer | Allocation-free automation consumer over one uniquely pinned wire payload |
| CRealtimeStretchProgramRuntime | One exact-publication live Stretch runtime |
| CRealtimeStretchStateSpec | |
| CRealtimeStretchStateBankAdmission | |
| CRealtimeStretchStateBank | Control-thread-prepared bank of clip-keyed realtime stretch processors |
| CRecordingTakeCommitRequest | |
| CSealedRecordingTake | |
| CRecordingSource | |
| CRecordingTrackConfig | |
| CRecordingCoordinatorConfig | |
| CRecordingMediaStager | Package-neutral durability boundary used before a Timeline transaction is published |
| CCommittedRecordingTake | |
| CRecordingCoordinator | Control-thread coordinator for capture completion, calibrated placement, media durability, and one atomic Timeline publication |
| CRendererCarryState | |
| CPlaybackProgramBlock | |
| CPlaybackProgramBlockLatch | |
| CStableRendererBlockView | |
| CStableRendererShell | |
| CTempoSyncHostTime | Opaque host-clock timestamp produced by the TempoSyncSource that owns the corresponding clock domain |
| CTempoSyncCommand | Backend-independent command bundle applied at the first output sample of an audio block |
| CTempoSyncBlockRequest | Timing information for one audio callback |
| CTempoSyncBlockState | Captured session mapping at both boundaries of one audio block |
| CTempoSyncPlayingProjection | Block-coherent projection of a timestamped start/stop state |
| CTempoSyncSource | Backend-neutral session-tempo boundary |
| CTrackAutomationProgramError | |
| CTrackAutomationProgram | Immutable compiler-supplied grouping of one track's compiled automation lanes |
| CTrackAutomationEvent | |
| CDeviceAutomationBatch | |
| CTrackAutomationRendererError | |
| CTrackAutomationRenderResult | |
| CTrackAutomationRenderer | Allocation-free block renderer for one prepared track automation program |
| CTrackMixerProgram | The compiled form of a track's own level and stereo placement |
| CTrackMixerChannelGains | Per-side multipliers for a stereo balance |
| CTrackMixerControlCursor | Streams one mixer control's value in timeline-sample order without allocating |
| CTransportRange | |
| CTransportSnapshot | |
| CTransportPlayhead | Where the transport is, published for a reader that is not the audio thread |
| CTransportLoopState | The transport's accepted loop control state |
| CMasterTransportConfig | |
| CMasterTransport | Master musical transport with one control-thread writer and one audio-thread consumer |
| CLaunchQuantize | Musical-boundary quantization for one launch |
| Nruntime | |
| Ndetail | |
| CCancelStateBase | Public part of the shared state so is_cancelled() can inline to one load |
| CLogSinkRegistry | |
| COkTag | |
| CErrTag | |
| CTraceAutostartConfig | A traced plug-in records when PULP_TRACE_PATH is set in its host's environment, but an out-of-process host (AUHostingService, where Logic runs AU v2 plug-ins) inherits nothing from a shell or launchctl setenv |
| CTimeoutController | A single owned, cancellable, joinable timeout |
| CActivityChannel | A fixed set of lock-free occurrence counters |
| CAliveToken | Shared, fail-closed lifetime signal for callbacks that may outlive an owner |
| CLease | A temporary lease proving that an owner-backed callback may safely use its referenced state |
| CAnalyticsEvent | Single analytics event |
| CAnalyticsDestination | Abstract destination for analytics events |
| CFileAnalyticsDestination | File-based analytics destination (writes JSON lines) |
| CAnalytics | Analytics singleton — thread-safe event logging |
| CWidgetTracker | Widget interaction tracker — automatically logs UI events |
| CAsyncStreamOptions | |
| CAsyncStream | |
| CBackgroundJobProgress | |
| CBackgroundJobContext | |
| CBackgroundJobHandle | |
| CBackgroundJobOptions | |
| CBackgroundJobService | |
| CRealtimeResourceSlot | Control-thread owner for resources prepared off the audio thread and read from the audio thread through an atomic raw pointer |
| CBigInteger | Arbitrary-precision unsigned integer backed by Mbed TLS MPI |
| CRuntimeBudgetPolicy | |
| CRuntimeBudgetRequest | |
| CRuntimeBudgetDecision | |
| CRuntimeBudgetFrameStats | |
| CRuntimeBudgetFrame | |
| CCancelRegistration | RAII registration returned by CancelToken::register_callback |
| CCancelToken | |
| CCancelSource | Move-only owner of a cancellation state |
| CCancellationToken | Former name of the shared token |
| CGcmOutput | Output of AES-GCM encryption: ciphertext + 16-byte authentication tag |
| CEd25519KeyPair | Ed25519 keypair (NaCl convention: secret key contains seed || public key) |
| CX25519KeyPair | X25519 keypair |
| CDynamicLibrary | |
| CExpressionEvaluator | Expression evaluator with persistent variable state |
| CExternalInputFrame | |
| CExternalInputPolicy | |
| CExternalInputCounters | |
| CExternalInputGate | |
| CFileSearchPath | |
| CFixedFunction | |
| CFixedFunction< R(Args...), Capacity, Alignment > | |
| CHighResolutionTimer | |
| CHttpRequest | |
| CHttpResponse | |
| CLocalisedStrings | Translation string lookup — maps keys to localized strings |
| CUuid | |
| CSessionId | |
| CRunId | |
| CObjectId | |
| CCorrelationId | |
| CEventEnvelope | |
| CInterProcessLock | |
| CJsonRpcError | Structured JSON-RPC error. Matches spec §5.1 |
| CJsonRpcResult | Result of a request handler: success JSON (result field) or error |
| CJsonRpcPeer | |
| CLicenseInfo | Parsed license key data |
| CLicenseValidator | License key validator — checks v1 RSA-signed or v2 AES-256-GCM keys |
| CLicenseGenerator | License key generator (server-side utility) |
| COnlineActivationOptions | Transport policy for OnlineActivation |
| COnlineActivation | Online license activation flow |
| CFileLogSinkOptions | |
| CFileLogSink | Appends records to a rotating file |
| CLogRecord | |
| CCaptureLogSink | Keeps the most recent records in memory |
| CScopedLogSink | Installs sink for the lifetime of the object and restores the previous sink after |
| CMacAddress | 48-bit MAC address (IEEE 802 EUI-48) |
| CFileIdentity | |
| CAccessPolicyTarget | |
| CMemoryMappedFile | |
| CMemoryMessageChannel | |
| CMessage | A single structured message as delivered by the channel |
| CMessageChannel | Abstract base for message-oriented channels |
| CDownloadProgress | |
| CHttpHeader | |
| CDownloadRequest | |
| CDownloadResult | |
| CResolvedRedirect | A redirect Location resolved against the request it answered |
| CModelAsset | |
| CModelEntry | |
| CInstalledModelRecord | |
| CListedModel | |
| CModelListResult | |
| CActivateModelResult | |
| CInstallModelResult | |
| CNamedPipe | |
| CTcpStream | Stream backed by a connected TCP Socket |
| CHttpStream | HTTP response as a readable Stream |
| CRequest | |
| CRange | |
| CErr | Wrap a value as a failure result |
| COk | Wrap a value as a success result |
| CResult | Result<T, E> — either holds a T or an E, never both |
| CResult< void, E > | Result<void, E> — an operation that either succeeded or failed with E |
| CScopeGuard | |
| CScopedNoAlloc | RAII guard that marks the current thread as "must not allocate" |
| CScopedAllocAllowed | Narrow RAII exemption that SUSPENDS the no-alloc contract on the current thread while alive, even when one or more ScopedNoAlloc guards are still on the stack |
| CSearchQueryOptions | |
| CSearchIndex | |
| CMatch | |
| CSeqLock | Lock-free reader/writer for reading multi-field structs as consistent snapshots |
| CSlot | Lock-free publication to a reader that must never block |
| CReadGuard | RAII pin |
| CHandoff | Lock-free transfer of ownership to a reader that must never block, plus a ring for handing the displaced value back so the audio thread never frees |
| CLocalPeerCredentials | Credentials reported by the kernel for the process on the other end of an OS-local stream |
| CSocket | |
| CSpscQueueTelemetry | |
| CSpscQueue | |
| CSpscRingIndex | |
| CStreamResult | Result of a Stream read/write |
| CStream | Base class for all Pulp byte streams |
| CFileStream | Stream backed by std::FILE* (for portability across Windows/POSIX) |
| CMemoryStream | Stream backed by an in-memory byte buffer |
| CPipeStream | Stream wrapper over NamedPipe |
| CSystemInfo | |
| CTemporaryFile | |
| CDiffEntry | |
| CTraceStopResult | Result of stopping a session: the flushed trace path + basic loss accounting so a caller can tell whether the ring dropped data under load (plan §0b #4) |
| CTraceOwnership | Opaque authority over one exact process-global trace generation |
| CTraceStartResult | |
| CTraceOwnershipStatus | Atomic view of the process-global session relative to one ownership token |
| CTracing | Process-global tracing controller |
| CScopedTracingAttachment | RAII attachment |
| CTripleBuffer | Lock-free triple buffer for publishing the latest value from a writer thread to a reader thread without blocking either side |
| CUdevMonitor | |
| CUrl | Parsed URL components |
| CWakeSignal | A wake signal from one or more producers (typically the audio thread) to a single consumer thread that sleeps until there is work |
| CWebSocketOptions | Options for WebSocketChannel construction |
| CWebSocketChannel | |
| CXmlDocument | Parsed XML document (RAII wrapper over pugi::xml_document) |
| Ntimeline | |
| Ndetail | |
| CDawProjectMediaViewResolver | |
| CContentHash | Durable SHA-256 identity for sealed media bytes |
| CAssetLocator | Non-authoritative location hint for resolving content by hash |
| CAssetRepresentation | Alternate fidelity, analysis, or cache form of the same logical asset |
| CAudioLoopPoint | Frame position at which sealed audio may loop |
| CAudioFrameRange | Half-open frame interval [start_frame, end_frame) |
| CAudioLoopInfo | Typed musical metadata attached to sealed audio content |
| CAutomationPoint | One identity-bearing automation value at a canonical musical tick |
| CAutomationPointPositionLess | Canonical ordering for authored automation points and curve storage |
| CAutomationCurveError | Automation curve failure with the offending and, when relevant, conflicting identities |
| CAutomationCurve | Immutable, position-ordered automation points |
| CAutomationTargetCases | Overload set for visiting an AutomationTarget with no generic fallback |
| CAutomationLaneError | Automation lane failure with the lane and related target identity |
| CAutomationLane | Immutable ownership of one authored automation curve and its logical target |
| CModelError | Model failure with the offending and, when relevant, conflicting identity |
| CSchemaIdentity | Versioned extension-schema identity |
| CItemIdAllocator | Monotonic allocator for non-zero document ItemIds |
| CEmptyContent | Clip content that intentionally carries no media, notes, or extension value |
| CMediaAsset | Project-owned sealed media metadata |
| CMediaRef | Borrowed range of frames from a project-owned MediaAsset |
| CSequenceRef | Reference to a sibling sequence in the same Project pool |
| CMusicalTimeRange | Musical clip placement in canonical ticks |
| CAbsoluteTimeRange | Absolute clip placement in samples at an explicit rational rate |
| CAbsoluteTimelineDuration | Sequence duration in absolute samples at an explicit rational rate |
| CClipPlaybackProperties | Clip-level audio controls |
| CNoteEvent | One identity-bearing MIDI-style note in canonical musical ticks |
| CMidiContent | Immutable MIDI clip content: start-then-identity-ordered notes with sparse deterministic modifiers, beside the controller and expression streams those notes sound against |
| CRegisteredContent | Extension-defined typed C++ content admitted by a SchemaRegistry |
| COpaqueContentLimits | Parser bounds retained with an opaque extension envelope |
| COpaqueContent | Exact validated JSON for an unavailable extension schema |
| CClipContentCases | Overload set for visiting a ClipContent with no generic fallback |
| CClip | Immutable identity-bearing placement of one ClipContent value |
| CLaunchQuantize | Musical-boundary quantization for one launch |
| CFollowAction | One weighted follow-action candidate |
| CFollowActionSet | Bounded weighted follow behavior attached to a slot |
| CSlot | One authored launch slot |
| CSlotList | Immutable authored slot order with persistent structural sharing |
| CIterator | Forward iterator that retains raw or persistent slot storage |
| CScene | Authored grouping of slots presented as one launchable column |
| CFollowDraw | Stable identity of one reproducible follow-action decision |
| CFollowResolution | Deterministic outcome and optional target slot of follow resolution |
| CWriterId | Stable non-zero identity of a document writer |
| CCommandId | Writer-scoped, monotonically assigned command identity |
| CTransactionId | Writer-scoped, monotonically assigned transaction identity |
| CDocumentRevision | Monotonic document snapshot revision used for optimistic admission |
| CUndoGroupId | Writer-scoped identity joining gesture transactions into one undo unit |
| CInsertClip | Inserts an identity-bearing clip into a track |
| CRemoveClip | Removes a clip by its owning coordinates and identity |
| CInsertAutomationLane | Inserts an automation lane into a track |
| CRemoveAutomationLane | Removes an automation lane by identity |
| CMoveClip | Replaces a clip's time range under an exact optimistic-value gate |
| CSetNoteVelocity | Replaces one note velocity under an exact optimistic-value gate |
| CReplaceNoteContent | Replaces the complete note event set of one note clip |
| CSetNoteEvents | Replaces the values of a named subset of one note clip's notes |
| CInsertNotes | Inserts a set of identity-bearing notes into one MIDI clip |
| CRemoveNotes | Removes a named set of notes under an exact optimistic-value gate |
| CSetClipPlaybackProperties | Replaces clip-level gain and fade controls under an exact value gate |
| CSetTempoMap | Replaces the complete project tempo map under an exact value gate |
| CSetMeterMap | Replaces the complete project meter map under an exact value gate |
| CCreateAsset | Adds one sealed recorded or imported media asset |
| CRemoveAsset | Removes a project-owned media asset by identity |
| CInsertTakeLane | Inserts one take lane and its owned take-identity subtree |
| CRemoveTakeLane | Removes a take lane and its owned take identities |
| CInsertTake | Inserts one take into an existing take lane |
| CRemoveTake | Removes one take from an existing take lane |
| CSetRecordArm | Replaces record-arm document intent under an exact optimistic-value gate |
| CSetActiveTakeLane | Selects the arrangement or an existing take lane under an exact value gate |
| CSetTakeComp | Replaces a take lane's canonical comp segments under an exact value gate |
| CSetTrackFreeze | Publishes or clears a pre-rendered track artifact under an exact value gate |
| CSetChordScaleLane | Replaces a sequence's complete chord/scale lane under an exact value gate |
| CSetDynamicsLane | Replaces a sequence's complete dynamics lane under an exact value gate |
| CInsertMarker | Inserts a sequence-owned marker identity |
| CRemoveMarker | Removes a sequence-owned marker by identity |
| CInsertRegion | Inserts a sequence-owned region identity |
| CRemoveRegion | Removes a sequence-owned region by identity |
| CSetGroove | Replaces a sequence's complete groove under an exact value gate |
| CInsertScene | Inserts a scene at an authored position in a sequence |
| CRemoveScene | Removes a scene and its owned slots by identity |
| CInsertSlot | Inserts a slot at an authored position in a scene |
| CRemoveSlot | Removes a slot from a scene by identity |
| CInsertSequence | Inserts a complete sequence and its owned identity subtree |
| CCloneSequence | Clones a sequence using an explicit, complete owned-identity mapping |
| CRemoveSequence | Removes a sequence and its owned identity subtree |
| CSetClipSequenceRef | Retargets a sequence-reference clip under an exact optimistic-value gate |
| CSetTrackMixer | Replaces track gain and pan under an exact optimistic-value gate |
| CInsertTrack | Inserts a track and its complete owned identity subtree at an authored position |
| CRemoveTrack | Removes a track and its complete owned identity subtree by identity |
| CSetTrackName | Replaces a track's authored name under an exact optimistic-value gate |
| CMoveTrack | Moves a track in authored order under an exact optimistic-position gate |
| CInsertDevice | Inserts a typed device declaration into a track's authored chain |
| CRemoveDevice | Removes a device declaration by identity |
| CMoveDevice | Moves a device under an exact optimistic authored-position gate |
| CRetargetDevice | Replaces device kind, binding, slot, stage, bypass, and wet/dry atomically |
| CSetDeviceState | Replaces the optional content-addressed opaque state reference |
| CInsertMidiExpressionLane | Inserts a controller/expression lane into a MIDI clip |
| CRemoveMidiExpressionLane | Removes a controller/expression lane from a MIDI clip by identity |
| CSetMidiExpressionLanePoints | Replaces one lane's authored points under an exact optimistic-value gate |
| CSetProjectTuning | Replaces the project-wide tuning statement under an exact value gate |
| CSetTrackTuning | Replaces one track's tuning override under an exact value gate |
| CSetRegion | Replaces one sequence-owned region under an exact value gate |
| CInsertModulator | Inserts a track-owned modulation source |
| CRemoveModulator | Removes a track-owned modulation source by identity |
| CSetModulator | Replaces a modulation source's declaration under an exact value gate |
| CInsertMacro | Inserts a track-owned macro control |
| CRemoveMacro | Removes a track-owned macro control by identity |
| CSetMacro | Replaces a macro control's declaration under an exact value gate |
| CSetMacroValue | Replaces only a macro's authored position under an exact value gate |
| CInsertModulationRoute | Inserts one authored source-to-parameter connection |
| CRemoveModulationRoute | Removes one authored connection by identity |
| CSetModulationRoute | Replaces a route's source, target, depth, and bypass under an exact gate |
| CCommandEnvelope | One command paired with its writer-scoped idempotency identity |
| CTransaction | Atomically admitted ordered command batch |
| CCompileContextSubscriptions | The declared set of context kinds one content renderer reads |
| CCompileContextView | The read side of the contract: a read-only window onto one pinned snapshot's context, narrowed to what its owner declared |
| CDawProjectImportError | Diagnostic returned when an import rejects the whole document |
| CDawProjectImportLimits | Hard resource ceilings for one import |
| CDeviceConfiguration | Authored device configuration excluding placement identity and opaque state |
| CDevicePlacement | Durable declaration for one logical placement in a Track device chain |
| CSessionLimits | Resource ceilings for one mutable document session |
| CCommandAuthority | The authority one command requires, as a class and intent pair |
| CWriterCapabilityMask | Fixed authority of one writer over command classes and retained size |
| CWriterToken | Move-only authority for submitting transactions to one DocumentSession |
| CProvenance | Opaque identity of one writer authority within one document session |
| CDocumentView | Atomically observed immutable project snapshot and its matching revision |
| CDocumentSession | Thread-safe owner of a revisioned Timeline document |
| CFileJournalError | File-journal failure with the offending byte and nested JSON error |
| CFileJournalLimits | File size, record size, and nested decode ceilings |
| CFileJournalOpenResult | Result of opening or recovering a native Timeline journal |
| CFileJournal | Native, crash-consistent Timeline persistence sink |
| CItemId | Nonzero monotonic identity for a Timeline-owned object |
| CJournalLimits | In-memory command-journal quotas |
| CJournalEntry | One contiguous revision transition retained by the command journal |
| CJournalSink | Synchronous durability boundary used by DocumentSession |
| CCommandJournal | Bounded, replayable in-memory log of contiguous document revisions |
| CMidiLaneAddress | Address of one continuous controller stream within a MidiContent |
| CMidiLanePoint | One authored value on a controller lane, positioned in canonical ticks |
| CMidiExpressionLane | One controller stream's authored points, ordered by (position, id) |
| CTrackIndexStats | Diagnostic counters for persistent track clip-index allocation |
| CLauncherIndexStats | Diagnostic counters for persistent launcher-index allocation |
| CTrackInput | Complete input for constructing a Track and its owned collections |
| CTrack | Immutable identity-bearing arrangement track |
| CClipView | Snapshot-owned random-access view of clips in timeline order |
| CIterator | Forward iterator that keeps the underlying persistent index alive |
| CChordScaleEvent | Harmonic statement in force from position until the next event |
| CChordScaleLane | Immutable chord/scale context lane owned by a sequence |
| CDynamicsEvent | Intensity statement in force from position until the next event |
| CDynamicsLane | Immutable intensity context lane owned by a sequence |
| CSequenceMarker | Named point on a sequence's musical timeline |
| CSequenceRegion | Named positive-duration span on a sequence's musical timeline |
| CGrooveStep | One timing offset and per-mille accent in a repeating groove table |
| CGrooveTemplateInput | Complete validated construction input for a GrooveTemplate |
| CGrooveTemplate | Immutable sequence-owned swing, timing-offset, and accent context |
| CSequenceInput | Complete construction input for a Sequence and its owned collections |
| CSequence | Immutable identity-bearing arrangement with tracks, annotations, context, and launch scenes |
| CSceneView | Snapshot-owned random-access view preserving authored scene order |
| CIterator | Forward iterator that keeps the persistent launcher store alive |
| CSessionStart | Absolute source/house-clock position corresponding to project time zero |
| CProjectInput | Complete input for constructing a Project and its identity domain |
| CItemLocation | Canonical ownership and ancestor coordinates for one project identity |
| CIdentityMutation | Planned identity-index transition accompanying an immutable model edit |
| CProjectIdentityStats | Diagnostic counters for persistent project identity-index allocation |
| CSequenceCompileStructureToken | Opaque, process-local identity for the part of a Project snapshot that determines nested-sequence and registered-content compile subscribers |
| CProject | Immutable root of a Timeline document and its monotonic identity domain |
| CIdRemapTable | Canonically ordered mapping from source identities to remapped identities |
| CExternalIdFixup | Optional non-throwing translation for an externally referenced identity |
| CRemapIdFixups | Independent external-reference fixups for media assets and sequences |
| CRemappedClip | Remapped clip snapshot and its complete owned-identity table |
| CRemappedTrack | Remapped track snapshot and its complete owned-identity table |
| CRemappedSequence | Remapped sequence snapshot and its complete owned-identity table |
| CRemappedProject | Remapped project snapshot and complete source-to-destination identity table |
| CModulationTargetCases | Overload set for visiting a ModulationTarget with no generic fallback |
| CModulator | A track-owned generator of modulation signal |
| CMacroControl | A track-owned named control that a performer sets and that drives parameters through ordinary modulation routes |
| CModulationSourceRef | Reference to the track-owned source a route reads |
| CModulationRoute | One authored source-to-parameter connection |
| CNoteModifier | Sparse playback modifier attached to one note identity |
| CNoteModifierDraw | One deterministic probability draw for a note key and loop pass |
| CNoteTransformCallbackFailure | Failure returned directly by a registered note-transform callback |
| CNoteTransformRegistration | Immutable registration for one versioned transform implementation |
| CNoteTransformError | Transform failure with nested callback, persistence, model, or transaction detail |
| CApplyNoteTransform | A typed, apply-time request |
| CNoteTransformPreview | Prepared durable transaction and resulting immutable document snapshot |
| CNoteTransformRegistry | Control-thread registry for pure note transforms |
| CDeviceParameterTarget | Format-neutral document target for a placed device parameter |
| CTrackMixerTarget | Format-neutral document target for one of the owning track's own mixer controls |
| CProductionDeclaration | What a piece of content declares about its own production |
| CTake | Immutable sample-anchored recording take referencing a project media asset |
| CTakeCompSegment | Exact absolute-time selection from one take for a comp |
| CTrackFreeze | Sealed offline-rendered track artifact and its source-plan identity |
| CTakeLane | Immutable alternate recording lane owned by a Track |
| CTrackMixer | Track-owned linear gain and stereo balance |
| CPersistenceError | Structured persistence failure |
| CDecodeLimits | Parser, migration, opaque-payload, and Timeline structure quotas |
| CJsonValue | Owning JSON DOM node with source byte bounds |
| CJsonObjectMember | Pair-like owning member of a JSON object |
| CParsedJson | Parsed JSON tree that owns the source bytes referenced by node offsets |
| CStructuralPreflightSuccess | Empty success value returned by structural preflight |
| CSchemaWriteSuccess | Empty success value returned by bounded schema writers |
| CBoundedJsonSink | Append-only JSON output sink with an enforced byte ceiling |
| CFieldSchema | Public field metadata for one registered schema type |
| CSchemaCodec | Immutable callback bundle and shared context for a registered type |
| CMigrationStep | One adjacent version transition for a schema type |
| CTypeSchema | Complete registration contract for one domain-qualified schema type |
| CSchemaError | Schema-registration failure with the affected type and version |
| CSchemaRegistration | Empty success value returned after registering a schema |
| CSchemaRegistry | Immutable, shareable registry of Timeline schema contracts |
| CSchemaRegistryBuilder | Mutable, single-owner accumulator for constructing a SchemaRegistry |
| CSchemaVersionTarget | Target version for one schema identity in a release projection |
| CSchemaReleaseMap | Immutable set of schema-version targets identified by a release label |
| CSerializeOptions | Output quota for project serialization |
| CSerializedSnapshot | Canonical serialized project plus extension-preservation status |
| CProjectSnapshotCounts | Structural item counts extracted from a serialized project |
| CProjectSnapshotSummary | Allocation-light metadata view for project browsers and admission checks |
| CSmfError | Diagnostic returned when an SMF operation rejects the whole conversion |
| CSmfImportLimits | Hard resource ceilings for one SMF import |
| CSmfImportOptions | Caller-selected resource and unsupported-event policy for SMF import |
| CSmfImport | Imported immutable Project plus tick-conversion fidelity metadata |
| CSmfExportOptions | Tick-grid, loss policy, and work bound for SMF export |
| CSmfExport | Encoded SMF bytes plus tick-conversion fidelity metadata |
| CDirtyItem | Canonical invalidation record for one item and its owning location |
| CDirtyContext | One sequence-owned context kind a transaction changed |
| CDirtySet | Owned canonical collection of incremental invalidations |
| CTransactionError | Structured transaction rejection |
| CReducedTransaction | Pure reduction result before revision publication |
| CCommitResult | Immutable state published by a successful session commit |
| CTuningReference | Durable statement of the tuning a project or one instrument plays in |
| CUndoLimits | Bounds the number and retained memory of undo groups in a session |
| Nproject_package | |
| CPackageError | Path-bearing package failure |
| CAtomicPublisher | Builds a private sibling directory and publishes it at a previously absent destination |
| CBlobReference | Exact package location of one SHA-256-addressed blob |
| CPackageLimits | Admission limits for untrusted project and blob bytes |
| COpenPackageResult | Validated package generation and its package-owned working directories |
| CPackageWriter | Cooperative exclusive writer for one stable package root |
| Nsequence | |
| CHostTransportProjector | Re-anchors the engine transport to the host's integer sample position on every callback |
| CSequenceProcessorConfig | |
| CSequenceProcessObservation | |
| CSequenceProcessor | Format-layer adapter for embedding an immutable PlaybackProgram in a VST3/AU/CLAP processor |
| Nsignal | |
| Ndetail | Round-2 effect-wave vocabulary |
| CStreamingAnalysisWindowT | |
| CEnvelopeStageClock | Sample counter for one envelope stage |
| CEnvelopeEngine | The DAHDSR superset state machine |
| CFftRealSplit | The packed split-complex form of a real transform, for Pulp's own frequency-domain stages (the overlap-add ConvolverT) |
| CFractionalDelaySplit | |
| CBasicLfoT | Shared implementation selected by the two explicit public LFO types below |
| CNonlinearOversamplingT | |
| CFixedHalfBandFir65 | |
| CLinearPhaseOversamplingStage2x | |
| CFixedOrderFirBranch | One polyphase branch of a block 2x stage: a direct-form FIR whose every output is the taps summed oldest-first, one multiply-add each (fused where the hardware has it; see fir_multiply_add()) |
| CLinearPhaseOversamplingBlockStage2x | The block form of LinearPhaseOversamplingStage2x, for OversamplerT: the same prototype and the same polyphase split, run a block at a time |
| CSaturatorShapeMath | The waveshaper family's three closed forms per member: the curve f, its derivative f' (needed for the bias normaliser), and its antiderivative F1 (needed for ADAA) |
| CDualTapResonatorT | Dual-tap TPT state-variable resonator (Zavalishin topology, identical to SvfT) returning the highpass and lowpass outputs from ONE tick |
| CTaps | |
| CCapacityLayout | |
| CReservationToken | |
| CProgramBank | |
| CSegmenter | |
| CReservationLedger | |
| COutputSplicer | |
| CSlicedFftPlanT | Resumable in-place radix-2 complex FFT (Cooley & Tukey 1965) |
| CCursor | Cursor over one transform |
| CZeroLatencyConvolverGroup | |
| CZeroLatencyConvolverCell | |
| CZeroLatencyConvolverOnePole | |
| Nchardelay | |
| CBbdChannel | One channel of the clocked BBD core, compander included |
| CModulatedAllpass | One modulated Schroeder allpass: y[n] = −g·x[n] + v[n−d], v[n] = x[n] + g·y[n] |
| CReverbTank | Dattorro's figure-of-eight reverb tank, one per channel |
| CDiffusionChain | The four-stage chain for one channel |
| CLangevin | Langevin function L(x) = coth(x) − 1/x and its first two derivatives |
| CJilesAthertonHysteresis | The hysteresis stage for one channel, in normalized units |
| CHysteresisHalfBandOversampler | Fixed-depth linear-phase half-band oversampling around a per-sample callback |
| COversampledHysteresis | Production-owned composition of a fixed wrapper and magnetic solver |
| CXorshift32 | |
| CSmoother | |
| CFractionalDelayLine | |
| COnePole | |
| CFirstOrderShelf | |
| CSvf2 | |
| CButterworth6Lowpass | |
| CFixedFir | |
| CEnvelopeFollower | |
| CReverseSegmenter | |
| CTapeInstability | Wow + flutter generator for one channel. Shared by both tape tiers |
| CTapeStandardChannel | Standard-tier tape coloration for one channel: the pre-line record EQ + saturation + playback EQ, and the post-line loss stand-in + DC blocker |
| CTapeLossGeometry | Head/tape geometry for the Wallace loss model. All lengths in metres |
| CLossShape | One fitted cascade in dimensionless frequency: corners are in units of the shape's own normalized variable and become hertz when multiplied by that term's scale factor |
| CTapeLossIirParams | The realized cascade's parameters in hertz, poles and shelves from both shapes concatenated |
| CTapeLossShapes | Fit both dimensionless shapes |
| CTapeLossIir | The realized IIR cascade for one channel |
| CTapeLossDesign | Everything designed for one tape speed: the gap FIR (speed-only) and the scaled IIR parameters, which are a pure function of geometry once the dimensionless shapes are fitted |
| CTapeLossStage | One complete, independently-stateful loss filter: the gap FIR followed by the fitted IIR tilt |
| CTapeChew | Intermittent dropout |
| CTapePhysicalChannel | The physical tier for one channel |
| CVintageChannel | |
| Ndrum | |
| CClapVoice | A hand clap |
| CCymbalVoice | A cymbal, built from a bank of comb filters and then deliberately de-tuned out of any musical relationship |
| CEngineMetadata | |
| CFmDrumVoice | A two-operator FM percussion voice |
| CFm8DrumVoice | An eight-operator FM percussion voice with a fixed algorithm table |
| CAlgorithm | One routing: for each operator, a bitmask of the operators that modulate it, and whether it is heard directly |
| CFm6DrumVoice | A six-operator FM voice with the classic thirty-two algorithm set |
| CAlgorithm | One routing |
| CFmWaveTable | A compact, license-clean bank of 26 phase-readable FM waves |
| CFmTransient | |
| CHatVoice | A hi-hat, and by extension every other struck metal in a kit |
| CHitLifeDecision | |
| CHitLife | Allocation-free shared sequencing for a voice's anti-machine-gun policy |
| CKickVoice | A kick drum |
| CKit | A set of percussion voices summed into one output, with choke groups |
| CClickLayer | The transient: a burst of noise through a lowpass, decaying in a few milliseconds |
| CNoiseLayer | The air a strike moves: a longer, coloured noise layer under the body |
| CShellLayer | A high-Q body resonance mixed back into an excitation path |
| CSubLayer | A sine an octave below the body, gated by the body's own envelope |
| CMembraneVoice | A struck membrane, modelled as its modes rather than as an oscillator |
| COutputStageT | The output stage every percussion voice ends with: fold, saturate, degrade, set the level, then apply an optional AHD/VCA |
| CSnareVoice | A snare drum |
| CStringVoice | A plucked or struck string, as a percussion voice |
| CTomVoice | A tom, and the analogue electronic-drum voice it generalises |
| CPresetData | |
| CVelocityResponse | How hard a hit changes the sound, beyond changing how loud it is |
| CVoice | The lifecycle every percussion voice shares |
| CZapVoice | A zap: a phase-distortion percussion voice |
| Nfdn | |
| CParamSpec | |
| CModeConfig | |
| CAllpassStage | |
| CAllpassCascade | |
| CSanitizedBiquadState | |
| CFracDelayT | |
| CHermiteHistory | |
| CEqBand | |
| CLoopEq | |
| CFluxBank | |
| CLanes | |
| CXorShift32 | |
| CMeanRevertingWalk | |
| CPhaseOsc | |
| CQuadratureBank | |
| CDelayModulationBank | |
| CPositionRing | |
| CButterworthPair | |
| CButterworthState | |
| CStereoPositionRing | |
| CStereoSection | |
| CStereoSectionLanes | |
| CStereoBiquadState | |
| CMultirateBridge | |
| CShimmerBank | |
| CTransientDucker | |
| CEnsembleChorus | |
| CTankControls | |
| CFdnTank | |
| Njunction | |
| CJunctionPair | One junction network: the exponential law over one or two antiparallel legs |
| Nnonlin_ambience | The calibration register: every number this module ships that is not cited to the literature lives here with a default and a range, so a reviewer finds them in one place rather than spread through the code |
| CVelvetTapDesign | Pure intermediate for one candidate in a velvet tap grid |
| Nosc | |
| CCorrection | A discontinuity's correction, split across the two samples it touches |
| CDcoProfile | OSC-DCO profile — data-driven timing parameters, no waveform or hardware capture |
| CDcoOscillator | A divider-clocked oscillator front-end composing the shared VaOscillator |
| CMinBlepAccumulator | Accumulates causal minBLEP corrections for discontinuities found between adjacent output samples |
| CPhaseEvent | A single phase discontinuity within one sample period |
| CPhaseAccumulator | Phase accumulator over the unit circle [0, 1), suitable as the clock for through-zero FM, hard sync, and per-sample modulation |
| CVaOscillator | Virtual-analog oscillator over the static shapes |
| CVcoTuning | The analog exponential pitch converter, as a pure control-voltage → frequency map |
| CWaveshaperParams | A per-shape lumped memoryless nonlinearity — the "analog character" the output stage imprints |
| CVcoOscillator | Virtual-analog VCO over the static shapes, with a circuit-flavored deterministic path |
| CWtOscillator | Modern wavetable oscillator over a set of band-limited WavetableTs |
| CLofiWtOscillator | Dedicated variable-clock ZOH wavetable oscillator (the lo-fi tier) |
| Nrt | |
| CRtWorkCounts | A snapshot (or a difference of two snapshots) of the counted operations |
| CRtWorkCounter | Measures the counted work done between construction and delta() |
| Nspectral_codec_detail | |
| CShape | |
| Ntape | Published tables and closed forms, free of any instance so a test can assert the SHIPPED constant rather than a copy of it |
| CEqTimeConstants | One standard's pair of time constants, in SECONDS |
| CHeadGapGeometry | Reproduce and record gap widths for one speed class, in METRES |
| CArchetypePreset | The complete baked preset for one machine |
| CVoicePartial | Which abscissa a SpectralEnvelope's break-points are measured along |
| CVoiceTable | A partial set. Fixed capacity; copying one is a memcpy, never an allocation |
| CAdditiveBankT | A sinusoidal-bank additive synthesizer |
| CSpectralEnvelope | A break-point spectral envelope: gain in dB as a function of frequency, interpolated linearly in the (log2 abscissa, dB) domain — the perceptually correct axes on both sides |
| CAdsrT | |
| CParams | |
| CAnalogVcfT | Measured panel voicings backed by a four-pole nonlinear OTA cascade |
| CStreamingAnalysisConfig | |
| CChromaFrameT | One complete chroma analysis window |
| CChromaFrontEndT | Fixed-capacity chroma analysis over caller-owned planar input |
| COnsetNoveltyFrameT | One complete novelty window |
| COnsetNoveltyFrontEndT | Fixed-capacity streaming novelty analysis |
| CAudioMatrixMixerT | Fixed-capacity signed audio routing matrix with sample-continuous gain ramps |
| CAutoDuckedSendT | Stereo send-gain processor for keeping an effect return out of the way of a source or sidechain signal |
| CConfig | |
| CBallisticsFilterT | Envelope follower with configurable attack and release times |
| CBeatRepeatCapturePlan | |
| CBeatRepeatPlanResult | |
| CBeatRepeatKernelT | |
| CConfig | |
| CSnapshot | |
| CBiasT | |
| CBiquadCoefficientsT | |
| CBiquadT | |
| CBlitOscillatorT | Band-limited impulse train evaluated by discrete summation |
| CBreakpointEnvelopePointT | |
| CBreakpointEnvelopeT | |
| CBridgedTComponents | Component values of the TR-808 bass drum's bridged-T network, in SI units (ohms, farads) |
| CQ43Leakage | Softplus fit of Q43's collector current against Vcomm (DAFx-14 Eq |
| CBridgedTResonator | The TR-808 bass drum's bridged-T network: one second-order system with three inputs (pulse shaper, feedback buffer, retrigger pulse) and two outputs (Vbt, the sound; Vcomm, the node that drives Q43's leakage) |
| COutput | |
| CCartesianWalkT | The 2-D (Cartesian) sequencer |
| CFrame | |
| CLogisticMapT | Logistic map: x <- r * x * (1 - x) (May, "Simple mathematical models with
very complicated dynamics", Nature 261, 1976) |
| CCharacterDelayT | |
| CCheckedRetainedByteCharge | |
| CChorusT | |
| CStereoSample | |
| CChorusEnsembleT | One chorus engine, four voicings. Stereo in place |
| CCalibration | One voicing's shipped calibration |
| CJunoModeSpec | The Juno's per-mode calibration |
| CClassicReverbT | |
| CCombFilterConfig | |
| CCombFilterSampleResult | |
| CCombFilterBlockResult | |
| CCombFilterT | A fixed-capacity, integer-delay comb-filter family |
| CCommutedStringExcitationCursorT | Per-voice traversal state for an immutable prepared excitation profile |
| CCommutedStringExcitationProfileT | A fixed-capacity body-shaped excitation shared by plucked-string voices |
| CCompressorT | |
| CParams | |
| CLimiterT | |
| CPartitionedConvolverT | Uniform partitioned convolution engine |
| CConvolverSpectrumArenaT | A fixed number of equal-length spectra in one contiguous, 64-byte-aligned block, each starting on a 64-byte boundary |
| CConvolverInputHistoryT | The convolver's input-side overlap-save history |
| CConvolverIrStateT | Pre-computed, audio-thread-ready state for a single impulse response |
| CConvolverIrSwapperT | Lock-free background-IR shuttle for PartitionedConvolver |
| CNonUniformPartitionedConvolverT | Two-stage non-uniform partitioned convolver |
| CCrossFeedbackMultitapDelayT | A wet-only stereo multitap delay with normalized tap feedback |
| CTap | |
| CCyclicStretchRegime | One of the two documented sonic regimes |
| CCyclicStretchT | The fixed-cycle splice stretcher |
| CDcBlocker | One-pole DC blocker (first-order high-pass) |
| CDeEsserT | A bounded mono de-esser primitive |
| CParams | |
| CDecayEnvelopeT | A one-shot percussion envelope: linear attack ramp, optional hold, then exponential decay |
| CDelayLineT | |
| CSnapChunk | One chunk of a block: samples [begin, end) |
| CSnapChunks | The chunks of [0, num_samples), consecutive and at most kSnapChunkSamples long, as a range |
| Citerator | |
| CDiffusionNetworkT | A bounded cascade of stereo Schroeder allpasses with energy-preserving inter-channel coupling |
| CStageConfig | |
| CConfig | |
| CDiodeBridgeGainT | The diode bridge as a gain element: an exact 1/(1 + x) divider plus the audio-path curvature that divider's diodes actually impose |
| CTransformerBracketT | One input or output transformer: band-limit, mild saturation, DC-blocked |
| CDiodeBridgeCompressorT | Two transformer brackets around one diode bridge, with a feedback sidechain |
| CClipperSolverConfig | |
| CDiodeClipperT | The diode-to-ground clipper: series resistor, shunt diode network, optional shunt capacitor |
| CFeedbackClipperT | The op-amp gain stage with the diode network either at its output or across its feedback resistor |
| CToneStackT | Pre/post tone shaping around the clipper: a two-pole tilt pair |
| CNoiseShaperStateT | |
| CDitheredQuantizationResultT | Public intermediate returned by the pure quantizer transition |
| CDitherQuantizerT | Stateful deterministic wrapper for per-sample and block processing |
| CDryWetMixerT | |
| CDustT | Deterministic discrete-time Poisson impulse source |
| CDynamicEqBandT | One internally keyed dynamic-EQ band |
| CParameters | |
| CGainReduction | Canonical gain-reduction meter value |
| CEnvelopeFollowerT | Discoverable name for Pulp's established peak/RMS envelope follower |
| CStereoEnvelopeFollowerT | Two-channel envelope follower with a detector-domain stereo link |
| CEarlyReflectionsT | A wet-only early-reflection renderer with a caller-authored tap pattern |
| CTap | |
| CArT | Attack-Release, gate-driven |
| CAdT | Attack-Decay one-shot, trigger-driven |
| CAhdT | Attack-Hold-Decay one-shot, trigger-driven |
| CDahdsrT | Delay-Attack-Hold-Decay-Sustain-Release with per-stage curves and velocity |
| CModEnvT | Delay-Attack-Hold-Decay modulation envelope with a signed depth |
| CTransientDetectorT | Level-independent transient detector: the normalized excess of a fast envelope follower over a slow one |
| CExpanderT | Stereo upward/downward expander with a continuous bounded gain law |
| CConfig | |
| CExplicitQResonatorBankT | |
| CBandRecipe | |
| CFastMath | Math helpers optimized for audio DSP |
| CFdnReverbT | |
| CFeedforwardCompressorT | Log-domain feedforward compressor with a soft-knee gain computer |
| CFetCompressorT | Feedback-topology FET compressor |
| CFftT | |
| CMultiBackendFft | Multi-backend FFT |
| CFilterDesign | Filter coefficient generation utilities |
| CFilterMorphT | |
| CEndpoint | |
| CFiniteStretchConfigT | |
| CFiniteStretchBuilderT | |
| CFirDesignPoint | |
| CFirLeastSquaresOptions | |
| CFirLeastSquaresResult | |
| CFirEquirippleBand | One contiguous approximation band for an equiripple design |
| CFirEquirippleOptions | |
| CFirEquirippleResult | |
| CMinimumPhaseFirOptions | |
| CMinimumPhaseFirResult | |
| CFirFilterT | FIR filter with arbitrary coefficients |
| CFixedIrConvolverT | Zero-latency convolution with one impulse response for the lifetime of a preparation, running whichever engine is cheaper for that IR length and block size |
| CFlangerT | The flanger |
| CFmOperatorRoutingT | Fixed-capacity routing for an operator network |
| CFmOperatorEngineT | Bounded melodic FM/PM operator engine |
| CEnvelope | |
| CFormantFilterBankT | A parallel bank of resonant band-pass sections for fixed source-filter colour |
| CFormantSpec | |
| CRecipe | |
| CThiran1Coefficients | |
| CFractionalDelaySampleResult | |
| CFractionalDelayHistoryT | Prepared history shared by any number of stateless Lagrange read heads |
| CFractionalDelayBlockResult | |
| CFractionalDelayLineT | A prepared mono fractional-delay line |
| CFreezeHoldSnapshotT | Value image of a FreezeHold's held state: everything needed to reproduce the held output bit-for-bit on a hold prepared with the same geometry |
| CFreezeHoldReferenceTiming | Time-based FreezeHold timing that reproduces the frame-count defaults (8 capture frames, 6 crossfade frames, 0.015 rad/frame walk) at the reference geometry they were tuned for: a 512-sample analysis hop at 48 kHz (RealtimePitchTimeProcessor's quality mode, 4096/512) |
| CFreezeHoldT | |
| CConfig | Two sizing modes |
| CFreezeLoopSamplerT | |
| CFrequencyShifterT | Shifts every frequency in a signal by the same number of Hz |
| CHilbertQuadratureNetworkT | A pair of allpass cascades whose outputs stand a quarter cycle apart across nearly the whole band — the analytic-signal splitter an SSB shifter needs |
| COutputs | |
| CSsbFrequencyShifterT | The single-sideband frequency shifter |
| CFuzzPairT | The two-transistor direct-coupled feedback pair |
| CGainT | |
| CSimpleMixerT | |
| CGateLogicT | Combinational logic on gate signals |
| CGrainView | A read-only view of one grain, for metering and grain-cloud displays |
| CGranularEngineT | |
| CGraphicEqBandT | |
| CGraphicEqT | A bounded cascade of configurable peaking bands for one audio channel |
| CHalfBandAllpassSectionT | One single-coefficient allpass section run at the sub-rate |
| CHalfBandIirDesign | Coefficients of one elliptic polyphase half-band filter, ascending |
| CHalfBandIirStageT | Fixed-storage polyphase half-band stage that filters whole blocks: the engine behind HalfBandUpsampler2xT, HalfBandDownsampler2xT, and the oversampler's polyphase lane |
| CHalfBandUpsampler2xT | 2x half-band upsampler |
| CHalfBandDownsampler2xT | 2x half-band downsampler |
| CDiatonicMapping | The result of one key+scale interval mapping |
| CDiatonicMapT | Key + scale interval mapper |
| CHarmonyEngineT | The diatonic harmonizer: YinTrackerT + DiatonicMapT + one PitchShifterT per voice |
| CHeadphoneCrossfeedT | Mixes a delayed, low-pass-filtered copy of each channel into the opposite ear |
| CIirDesign | Chebyshev / Elliptic IIR design utilities |
| CMapClipT | Map a finite control interval to another interval and clip outside it |
| CIndexedControlT | Read an externally indexed control waveform |
| CInterpolator | Collection of interpolation algorithms for reading between samples |
| CKarplusStrongT | A plucked string: a delay line fed back through a loss filter |
| CLadderBankT | Voices independent LadderFilterT voices advanced together |
| CLadderFilterT | |
| CLatencyAwareControlSmoother | |
| CConfig | |
| CLeslieRotaryT | A rotary speaker cabinet: two rotors, a crossover, a stereo mic pair and a reflective box |
| CLfoT | |
| CEffectLfoT | |
| CLfoShapeParams | The shape parameters the deterministic waves take |
| CLfsrT | Configurable Fibonacci linear-feedback shift register with a weighted register-to-output projection |
| CLinkwitzRileyT | |
| CSectionCoefficients | |
| CBandSplit | |
| CLinkwitzRileyCrossoverT | Fixed-capacity Linkwitz-Riley crossover for two or more ordered bands |
| CFrame | |
| CSampleRateReducerT | Sample-and-hold rate reducer with clock jitter and a reconstruction filter |
| CLofiChainT | The three lo-fi stages in the order the hardware they model applies them: quantise the word, hold it at a lower clock, then push it through an output stage that cannot represent the smallest codes |
| CLogRampedValueT | Exponentially-smoothed value for parameters where linear ramping sounds wrong (pitch, frequency, gain in dB) |
| CLookupTableT | Pre-computed function lookup table with linear interpolation |
| CLoudnessCompensationConfig | Every tunable of the stateful stages |
| CMakeupLimits | |
| CLegSpectra | The long-term spectra of the two legs on one bin grid, K-weighted, on a common scale |
| CBandPowerGain | One band of a band-wise response: its frequency span and power gain |
| CSpectrumCdf | The normalised cumulative of a power spectrum on a uniform bin grid |
| CMinimumPhaseResponse | The minimum-phase response with a given magnitude on an FFT grid, by the folded real cepstrum: ln|H| -> cepstrum -> fold onto positive quefrency -> exp(FFT) |
| CSpectrumBands | A band-compressed, rate-independent copy of a LongTermSpectrum's estimate, for saving with a session and restoring warm |
| CMaterialChangeDetector | Detects a genuine change of material from the gap between the make-up the fast and the slow estimates give the current shape |
| CLongTermSpectrum | |
| CMakeupTarget | What the make-up gain is heading for |
| CLowpassGateT | A lowpass gate: an amplitude gate and a lowpass filter driven by one control signal with deliberately asymmetric dynamics |
| CLpgT | Vactrol-modelled low-pass gate |
| CMatrix | NxN matrix stored in row-major order |
| CVec3 | Transform a 3D vector by a 4x4 matrix (assumes w=1) |
| CMirroredHistoryBuffer | A single-thread circular history whose complete oldest-to-newest window is always physically contiguous |
| CModMatrixT | |
| CSlot | One routing |
| CDenseModMatrixT | Dense Round-2 matrix facade |
| CSlewLimiterT | |
| CConstantTimeSlewLimiterT | Distance-independent portamento used by the Round-2 effect and sequencing lane |
| CSampleHoldT | Latch a value on a clock's rising edge, with optional glide to the new value instead of a step |
| CAttenuverterT | y = x * gain + offset, with gain allowed to go negative |
| CRectifierT | Full- or half-wave rectification |
| CComparatorT | Threshold comparator with hysteresis — the bridge from the signal domain to the event domain |
| CSignalComparatorT | Signal-valued comparator from the Round-2 patching lane |
| CQuantizerT | Snap a control value to N equally spaced levels across a range |
| CCurveT | Response shaper for a unit control: the stage-curve law, or smoothstep |
| CModalMode | One resonant mode of a vibrating object: frequency, decay time, and impulse-response amplitude |
| CModalShape | The spatial eigenfunction of one mode along a body's normalized length coordinate x in [0, 1]: phi(x) = sin(pi * half_waves * x + end_phase) |
| CModalBankT | Bank of two-pole modal resonators, stored structure-of-arrays in lane groups so the per-sample state update auto-vectorizes across modes |
| CModalSpecExcitation | How the resonator is struck |
| CModalShapeMap | A mode shape sampled on a uniform grid across the object's normalized extent [0, 1], mode-major |
| CModalSpecTolerances | The PASS criteria a render of this spec must meet |
| CModalSpec | A modal instrument, complete |
| CModalSpecDiagnostics | What a parse found beyond the spec itself. Always populated; read it |
| CModulationCurve | Curve strength is dimensionless and legal in [0, 1] |
| CLoudnessBiquadCoefficients | |
| CKWeightingCoefficients | |
| CChannelLevels | Per-channel level measurements computed on the audio thread |
| CMultiChannelMeterData | Complete metering snapshot for all channels, published lock-free |
| CMultiChannelBallistics | Configurable ballistics for multi-channel meter display (UI thread) |
| CChannel | |
| CMultiChannelMeterT | Audio-thread metering processor |
| CMultichannelPhaseCoordinatorT | RT contract: prepare() allocates internal phase/magnitude storage and must run off the audio thread |
| CNlmsAdaptiveFilterT | |
| CResult | |
| CNoiseGateT | |
| CParams | |
| CNoiseMorpherT | RT contract: prepare() and prepare_masked_scratch() allocate storage and must run off the audio thread |
| CNoiseSourceT | A deterministic, colourable noise generator |
| CNoiseTiltT | Continuous spectral-tilt noise source built from NoiseSourceT's canonical seeded white stream and a fixed cascade of canonical BiquadT shelves |
| CNonlinAmbienceT | The nonlin / gated ambience engine. Stereo, processed in place |
| CTap | One velvet tap: where to read, how much to scale it, and which spectral segment it belongs to |
| CMultistageWavefolderT | A sequential wavefolder whose stage drive increases through the chain |
| CChebyshevHarmonicShaperT | A fixed-storage Chebyshev-series transfer function |
| CNonlinearRingModulatorT | An internally carried ring modulator with ideal and diode-ring models |
| COfflineStretchOptions | Whole-input render options |
| COfflineStretchT | Offline stretcher |
| CWindow | Material-adaptive window/overlap recommendation |
| COscillatorT | |
| COtaCascadeFilterT | Voicing-neutral four-pole nonlinear cascade with fixed-storage oversampling |
| CConvolverT | |
| COversamplerT | |
| CLatency | |
| CPannerT | |
| CStereoSample | |
| CParallelDynamicsConfigT | |
| CPreparedParallelDynamicsConfigT | |
| CParallelDynamicsMixerT | Blend true-stereo dry input with an already-processed true-stereo wet path |
| CParametricEqBandT | |
| CParametricEqT | A bounded series cascade of arbitrary parametric bands |
| CParticleCollisionExciterT | Bounded stochastic collision model for shaken particle instruments |
| CCollisionEvent | |
| CParticlePercussionVoiceT | Single particle-percussion voice composed from the shared collision model and Pulp's existing resonators |
| CPathLatencyAlignerT | Aligns N already-processed paths to the largest declared intrinsic latency |
| CClickFreePathSwitcherT | Fixed-capacity, click-free path selector |
| CPhaseDistortionOscT | Phase distortion: a cosine read at a warped phase |
| CPhaseVocoderConfig | |
| CPhaseVocoderT | |
| CPhaserT | |
| CPhaserStagesT | A cascaded first-order-allpass phaser |
| CPitchShifterT | Time-domain ratio pitch shifter: dual-tap crossfaded modulated delay |
| CFeedbackLoopProcessorT | Interface for a processor placed inside the feedback loop |
| CPitchedFeedbackDelayT | |
| CConfig | |
| CPolynomial | Polynomial evaluation and manipulation utilities |
| CMat2T | Simple 2x2 matrix for biquad coefficient manipulation |
| CMat3T | Simple 3x3 matrix for state-space filter representations |
| CProbGateT | Passes each incoming trigger with a stated probability, deterministically |
| CProcessingSwitchPlan | How long each phase of a switch lasts, in samples |
| CProcessingSwitchCrossfadeT | The audio-thread state of one switch |
| CProcessorChainT | Chain multiple DSP processors in series |
| CProcessorDuplicatorT | Duplicates a mono processor across N channels |
| CPitchTimeStreamFinalizePlan | |
| CRealtimePitchTimeConfig | |
| CRealtimePitchTimePreparedGeometry | |
| CRealtimePitchTimeProcessorT | |
| CReedWaveguideLoopT | Owns and oversamples one complete reed -> bore -> bell feedback loop |
| CResamplerQuality | Quality knobs for the Kaiser-window prototype |
| CResamplerProcessResult | |
| CResamplerT | |
| CReverbT | |
| CStereoSample | |
| CReverseBufferT | A mono streaming reverse-window processor |
| CConfig | |
| CRiseFallGeneratorT | |
| CXorshift32 | Xorshift32 (Marsaglia, "Xorshift RNGs", J |
| COuWalkT | Ornstein-Uhlenbeck walk (Uhlenbeck & Ornstein, Phys |
| CDriftT | Two decorrelated OU walks presented as the two things drift is actually wired to: a pitch ratio and a unit fraction |
| CRunglerT | The Hordijk shift-register / DAC chaos sequencer |
| CSaturatorAdaa2 | Second-order antiderivative antialiasing over one shape, in the curve's own argument domain (Bilbao, Esqueda, Parker & Välimäki, IEEE SPL 24(7), 2017) |
| CSaturatorT | The memoryless saturation stage |
| CQuantizeScaleT | CV-to-scale quantizer on the 1 V/octave standard |
| CScannerVibratoT | The motor-scanned tapped delay line |
| CScopeCaptureConfig | |
| CScopeCaptureFrameT | |
| CScopeCaptureT | |
| CScopedFlushDenormals | |
| CAlignedBufferT | RAII aligned buffer with SIMD-friendly access |
| CSincResamplerT | |
| CSixBandEqT | A low shelf, four peaking sections, and a high shelf in series |
| CParameters | |
| CSmoothedValue | Linear smoothing for control-rate parameters |
| CSoftBypassT | |
| CSosCascadeT | Executes a bounded cascade of normalized second-order sections (SOS) |
| CCepstralEnvelopeConfigT | |
| CCepstralEnvelopeResultT | |
| CCepstralEnvelopeAnalyzerT | Log-magnitude spectrum to liftered log-envelope |
| CAutocorrelationResultT | |
| CLevinsonDurbinResultT | |
| CLpcAnalysisResultT | |
| CLpcAnalyzerT | |
| CSpeakerDriverArchetype | One driver's published-form Thiele-Small set plus the two geometry figures the cabinet and breakup stages need |
| CSpeakerModelT | Physics-based speaker + cabinet + microphone emulator |
| CBreakupMode | One DIMENSIONLESS breakup mode: a ratio to the archetype's anchor frequency plus a Q and a gain |
| CSpectralBandT | |
| CSpectralBandLayoutT | |
| CSpectralBandResolutionT | Control-side report of how discrete FFT bin centers represent an authored viewport |
| CSpectralMaskTableT | |
| CSpectralCrossSynthesisPrepareConfigT | |
| CSpectralCrossSynthesisConfigT | |
| CSpectralCrossSynthesisT | |
| CSpectralDelayBreakpoint | |
| CSpectralDelayMatrixRecipe | |
| CSpectralDelayMatrixTable | |
| CSpectralDelayMatrixConfig | |
| CSpectralDelayMatrixGeometry | |
| CSpectralDelayMatrixT | |
| CSpectralEnvelopeShifterConfig | |
| CSpectralEnvelopeShifterT | |
| CSpectralFeatureFrameT | One complete control-rate spectral-feature window |
| CSpectralFeatureFrontEndT | Fixed-capacity streaming centroid, flatness, rolloff, and flux analysis |
| CSpectralStreamGeometry | Offline profile 1: symmetric float Hann, unscaled forward FFT, 1/N inverse, local-origin phase, indexed channels, full-overlap startup and squared-window OLA normalization (threshold 1e-9f) |
| CSpectralFrameStamp | |
| COwnedSpectralStream | Arrays have exact element counts, with no hidden vector capacity |
| CEncodedSpectralStream | |
| CSpectralCodecMemory | |
| CSpectralCodecResult | |
| CSpectralFrameEngineConfig | Configuration for a SpectralFrameEngine |
| CSpectralFrameEngineGeometry | |
| CSpectralFrameEngineT | Streaming multichannel STFT/WOLA engine |
| CSpectralGateT | |
| CSpectralFrameBlurT | |
| CSpectralMaskProcessorConfigT | |
| CSpectralPreMaskStageT | A frame-domain stage that SpectralMaskProcessorT::process() runs on each analysis frame group before the mask |
| CSpectralWetSourceStageT | A time-domain stage that SpectralMaskProcessorT::process() runs on each block before the wet path's analysis |
| CSpectralMaskProcessorT | |
| CSpectralMorphT | |
| CConfig | |
| CSpectrogramColor | RGBA color for spectrogram pixels |
| CColorMapper | Maps a normalized value [0,1] to a color using a predefined ramp |
| CFrequencyAxis | Utilities for mapping FFT bins to display coordinates |
| CSpectrogramBuffer | Scrolling spectrogram buffer that accumulates STFT frames as rows |
| CSpectrumTraceConfig | |
| CSpectrumTraceFrameT | |
| CSpectrumTraceT | |
| CSquareOscBankT | A bank of band-limited square-wave oscillators at fixed frequencies, summed into one output |
| CPartial | One partial of the bank: a frequency in Hz and a linear weight |
| CStageSeqT | The pulse-count stage sequencer |
| CFrame | One sample of sequencer output |
| CStagedTransition | |
| CStftConfig | Configuration for an STFT processor |
| CStftFrameT | A single completed STFT frame: magnitude (linear or dB) and phase |
| CStftT | Allocation-stable STFT processor with single-thread ownership |
| CStnConfig | |
| CStnMasksT | Per-frame soft masks. Each spans num_bins and sums to ~1 per bin |
| CStnDecomposerT | |
| CStretchPreset | The tunable subset of OfflineStretchOptions that defines a "character preset" |
| CSubOscillatorT | A one- or two-octave divider derived from an explicit parent phase |
| CStereoSampleT | |
| CSupersawT | |
| CSvfT | |
| CCoefficients | The TPT state-variable coefficients for a sample rate, cutoff and resonance (Q): g = tan(pi fc / fs), k = 1 / Q, a1 = 1 / (1 + g (g + k)), a2 = g a1, a3 = g a2 |
| CSvfBankT | Voices independent SvfT voices advanced together |
| CTapeMachineT | The tape machine insert |
| CTapeEqSection | One first-order EQ section — a (curve, speed) record network, or its exact inverse |
| CTapeCompanderT | The 2:1 / 1:2 linear-dB compander pair |
| CTempoDelayResult | |
| CTempoDelayTime | Fixed-state controller for deterministic delay read-time modulation |
| CTempoDelayWrapperProcessResult | |
| CTempoDelayWrapper | A wet-only, stereo delay that owns its histories and feedback routes |
| CTiltEqT | A reusable spectral slope built from a fixed cascade of high shelves |
| CConfig | |
| CTptFilterT | First-order TPT (trapezoidal integration) filter |
| COutputs | Process and return all three outputs at once |
| CTransferCurvePointT | |
| CPreparedTransferCurveT | |
| CTransferCurveT | Audio-thread processor for a fixed-capacity arbitrary transfer curve |
| CTransientDesignerT | Separates attack and sustain by comparing exact-timing peak envelopes |
| CTransientPhasePolicyT | |
| CConfig | |
| CTransitionMixerT | |
| CTransportEdgeT | Converts a run level and a reset level into the (run_high,
reset_edge) pair the sequencers consume, and optionally detects the clock edge alongside them |
| CFrame | One sample of transport, decoded |
| CHystereticTriggerDetectT | Hysteretic continuous-CV edge detector |
| CTriggerDetectT | Rising-edge detector with a refractory period |
| CGateGenT | Trigger in, fixed-length gate out |
| CClockDividerT | Pass every Nth trigger |
| CClockMultT | Emit N evenly spaced event triggers per measured input period |
| CSignalClockMultT | Continuous-signal clock multiplier |
| CBurstGenT | One trigger in, a burst of N triggers out, with a spacing curve and a level ramp |
| CHit | |
| CTrigDelayT | Delay a trigger by a fixed time, through a small fixed-capacity queue |
| CTruePeakLimiterT | |
| CParams | |
| CTwoPoleResonatorT | A single decaying resonance: one complex pole pair, excited by whatever the caller feeds it |
| CUnisonSpec | Control-side configuration for a fixed unison layout |
| CUnisonVoiceParameters | |
| CUnisonLayout | |
| CUnitDelayT | One sample of explicit signal memory |
| CVactrolConditionerT | The asymmetric one-pole that lags a control signal the way a photoresistor lags its LED |
| CVcaT | Voltage-controlled amplifier |
| CVcaCompressorT | True-RMS, log-domain, single-time-constant feedforward compressor |
| CVelvetNoiseDrawT | |
| CVelvetNoiseGridT | Sequential convenience wrapper over the coordinate-keyed pure draw |
| CDelayVibratoT | True pitch vibrato: a fractional delay whose tap position is modulated by a sine, which scales the frequency of everything passing through it equally |
| CPhaseVibratoT | Magnatone-style phase vibrato: N cascaded first-order allpass stages whose corner is driven straight from the LFO, summed back against the direct path |
| CUniVibeT | Univibe-style phase vibrato: four allpass stages at deliberately unequal corners, all swept together by one lamp-and-photocell control chain |
| CVocoderT | A classic channel vocoder: analysis bank → envelopes → matched synthesis bank |
| CWaveguideJunctionT | A bounded N-port pressure-wave scattering junction |
| CWaveguideLineT | A passive bidirectional waveguide segment |
| CReedExciterT | A normalized pressure-controlled reed valve |
| CWaveguideReflectionFilterT | A passive boundary filter with H(z) = g (1 - a) / (1 - a z^-1) |
| CWavesetTransformerT | A bounded, allocation-free-at-runtime waveset transformation engine |
| CCapacity | |
| CProgramStep | |
| COperationProgram | |
| CWaveShaperT | |
| CWavetableEntryT | One single-cycle wavetable plus the maximum playback frequency it remains bandlimited at |
| CWavetableT | Wavetable oscillator with band-switching |
| CWavetableBankT | Linear-interpolated morph across N Wavetables |
| CWindowFunction | |
| CYinTrackerT | Monophonic fundamental-frequency estimator, after de Cheveigné & Kawahara 2002 [1], steps 1–5 |
| CZeroLatencyConvolverT | See the file doc block for the schedule and its lineage |
| CZeroLatencyConvolverDesign | Zero-latency non-uniform partitioned convolution engine |
| Ndawproject | |
| CExportOptions | |
| Ndsl | |
| CDslParamDescriptor | |
| CDslBusLayout | |
| CDslError | |
| CDslProcessor | |
| CPulpFaustUI | |
| CZone | |
| CPulpFaustMeta | |
| CFaustProcessor | |
| Ntimebase | |
| Ndetail | |
| CRatchetSubdivisionCursor | |
| CBeatFraction | |
| CMeterSignature | |
| CMeterPoint | |
| CBarPosition | |
| CBarTickPosition | |
| CMeterMap | |
| CCompiledMeterMap | |
| CTempoPoint | |
| CTempoMap | |
| CSampleToTickResult | |
| CCompiledTempoMap | |
| CTempoCursor | |
| CTempoTickCursor | |
| CRandomCoordinate | |
| CHostGridAnchor | |
| CGridProjectionRange | |
| CGridProjectionRequest | |
| CGridProjectionPoint | |
| CGridProjectionResult | |
| CGrooveKernelStep | |
| CGrooveKernelInput | |
| COrderPreservingGrooveKernel | |
| CInlineGrooveInput | |
| CInlineGrooveProjector | |
| CLoopRegion | The loop bounds a transport honours, in document ticks |
| CSwingRatio | |
| CRatchetProjectionResult | |
| CSamplePosition | |
| CRationalRate | |
| CTickDuration | |
| CTickPosition | |
| CMonotonicBeat | |
| CTriggerProbability | An exact probability ratio for an authored trigger |
| CTriggerCell | The authored data at one track and step coordinate |
| CTriggerEvent | |
| CTriggerProjectionResult | |
| CTriggerGrid | Fixed-capacity authored trigger data with allocation-free tick projection |
| Ntimeline_agent_view | |
| CError | |
| CLimits | |
| COmissionSummary | Count and SHA-256 commitment for authored rows omitted directly at one node |
| CClipSummary | |
| CTrackSummary | |
| CSequenceSummary | |
| COutline | |
| CRegionCursor | |
| CRegionRequest | |
| CRegionPage | |
| COutlineChange | |
| COutlineDiff | |
| CDirtyRevisionRange | Adjacent revision range associated by the caller with one DirtySet |
| CAgentView | Immutable, bounded projection of one pinned DocumentView |
| Ntimeline_editor | ScriptedUiHost is a SequencerUiHost whose playhead is written by the caller instead of an engine, and which keeps what a view emitted so a test can read it back |
| CEditIntent | One editing step expressed without reference to the device that produced it |
| CNoteEditIntent | One validated note editing step, independent of pointer or view geometry |
| CValidatedNoteEditIntent | A note intent that passed validate_note_edit_intent and may cross a host seam |
| CEditIntentIdentity | Identities a lowered transaction needs and an intent deliberately does not carry |
| CEditGestureSubmitOutcome | Result of submitting one issued gesture transaction through its allocator |
| CEditGestureSubmitError | A refusal before submission, or an inconsistent successful session result |
| CEditGestureIdentityIssue | One opaque, single-owner identity issue awaiting a submission outcome |
| CEditGestureIdentityAllocator | Allocates one undo group and submits a construction-safe stream of gesture identities |
| CUndoGestureBudget | What one open gesture may spend against the undo budget |
| CGridLine | Describes one visible musical boundary in projected screen coordinates |
| CGridLineResult | Carries the generation status and the number of lines written |
| CProjectedHitCandidate | One timeline item after a front-end projects it into pixel space |
| CProjectedHit | The identity and region selected from a projected candidate set |
| CScriptedProgram | What the caller scripts. Held by value inside the host's current program |
| CScriptedUiHost | |
| CAuditionRecord | One audition the host was asked for, with the outcome it gave back |
| CSelection | Identity-only editor state that never enters the document or its undo history |
| CUiPlayhead | One complete reading of where playback is |
| CAuditionRequest | What a view asks to hear, in document terms only |
| CAuditionHandle | Names a sustained audition so it can be ended |
| CAuditionResult | Returned by value so a view driven by a host that cannot audition is observable in a test without a mock — the same reason StepGridViewBase returns PumpResult rather than relying on an unobservable side effect |
| CIntentResult | |
| CSequencerUiHost | The vocabulary-independent half of the seam: where playback is, and asking to hear something |
| CSequencerUiHostT | Adds intent submission for one intent vocabulary |
| CSnapGrid | A validated musical grid whose phase restarts at every authored bar |
| CTimePitchQueryResult | Notes intersecting one time-and-pitch query, plus structural work diagnostics |
| CTimePitchIndex | Immutable index for visible-note and marquee queries |
| CTrackEditIntent | One track-arrangement step expressed without reference to the device that produced it |
| CTrackCreateIntent | One complete track insertion expressed without device coordinates |
| CTrackHeaderProjection | Maps authored track order to header rows and reorder insertion neighbors |
| CPixelSpan | A one-dimensional pixel range owned by the editor kernel |
| CTickProjection | Projects a visible musical-time range onto a horizontal pixel span |
| CPitchProjection | Projects an inclusive MIDI pitch range onto piano-roll rows |
| Ntimeline_view | |
| CArrangerLayout | A resolved tick/pixel mapping, supplied by whoever owns the viewport |
| CArrangerView | Arranger canvas over a timeline::Project |
| CPianoRollLayout | A resolved note lattice, supplied by whoever owns the viewport |
| CPianoRollPitchRuler | Pitch ruler for a piano roll, using the shared MIDI keyboard interaction and C4 naming convention over the editor kernel's resolved pitch projection |
| CPianoRollView | Piano roll over one MIDI clip of a timeline::Project |
| Ndesign | |
| CAdherenceFinding | |
| CGalleryCard | One tagged card discovered by its leading @dsCard magic comment |
| CHandoffScreen | One screen the handoff describes: a display name, an optional relative path to its source (from a (path) after the name), and its exact-value specs (each a key/value bullet under the screen's heading) |
| CHandoffContract | The parsed handoff contract |
| CKnobWrite | One parameter write a knob position produces |
| CKnobPosition | One selectable position of a knob |
| CKnobSpec | A declared knob: a stable id, a human label, its kind, and its positions in authored order (Slider positions are additionally sorted by at on parse) |
| CKnobSchema | A design's declared set of knobs |
| CKnobEffect | The concrete effect of setting a knob to a value: its writes split by target |
| CKnobApply | The result of applying a knob to a design artifact |
| CLedgerAsset | One recorded artifact revision |
| CDesignLedger | The whole project ledger: a format id plus the recorded assets |
| CManifestToken | One token in the compiled allowlist: a name an importer/codegen may bind to, its kind, and its value in the chosen appearance |
| CManifestComponent | One component contract: a widget an importer may target and the exact theme tokens it legitimately paints through (its reskin allowlist) |
| CDesignManifest | The compiled design contract |
| CComponentInfo | One cataloged component: the bridge between a Figma component and its native C++ widget, plus enough metadata for tooling and docs to use it well |
| CTweakParam | One parameter in the block: a key and its JSON-encoded value |
| CEditBlockSpan | Where the block sits in the host text, as byte offsets |
| CRewriteResult | Result of a rewrite: the new full artifact text plus whether anything outside the block changed (it must not — this is a self-check the caller can assert) |
| CVariantProperty | One property parsed from a variant name: "Size=Large" -> {"Size","Large"} |
| CContractProp | One property in the synthesized contract: its name, the sorted-unique value set observed across the set (its enum), and the chosen default value |
| CVariantIssue | A named issue about a variant set that could not be cleanly collapsed |
| CComponentContract | The typed component contract synthesized from a variant set |
| Ntest | |
| Naudio | |
| CCheckResult | Outcome of one signal assertion |
| CAnalyzeOptions | Options for analyze() |
| CChannelMetrics | Per-channel facts about a rendered buffer |
| CBufferMetrics | Whole-buffer facts. channels.size() == channel count |
| CFrequencyEstimate | Result of estimate_frequency() |
| CResponsePoint | One point on a response curve: frequency and magnitude in dB |
| CResponseCurve | Magnitude/frequency-response curve |
| CResponseOptions | Options for the response analyzer. Lengths must be powers of two |
| CPhasePoint | One point on a phase/group-delay curve |
| CPhaseCurve | Phase / group-delay curve of a transfer function |
| CGroupDelayOptions | Options for the phase/group-delay analyzer. Lengths must be powers of two |
| CHarmonic | One harmonic's contribution to a distortion measurement |
| CThdResult | Total harmonic distortion result |
| CThdOptions | Options for the THD analyzer |
| CToneFit | Least-squares fit of a single sinusoid at a known frequency |
| CAliasComponent | One expected component of the ideal series, and what was measured where it landed |
| CAliasOptions | Options for measure_aliasing |
| CAliasReport | Three-way classification of an oscillator's output into harmonic / alias / noise, with the worst in-band alias called out |
| CModulationSidebandOptions | Options for measure_modulation_sidebands |
| CModulationSidebandReport | Where a steady tone's energy went after a periodic modulation was applied to it |
| CLatencyEvidence | One processor's latency evidence: the facts, the measurement, the verdict |
| CDelayedNullOptions | Knobs for measure_delayed_passthrough |
| CMarkerOffsetOptions | Knobs for measure_marker_offset |
| CMeasuredMode | One resonant mode recovered from a rendered impulse response |
| CModeAnalysisOptions | Options for analyze_modes |
| CModeAnalysis | Modes recovered from an impulse response, strongest first |
| CMeasuredPartial | One tracked partial of a (quasi-)harmonic sound |
| CInharmonicityOptions | Options for measure_inharmonicity |
| CInharmonicityResult | Inharmonicity of a (quasi-)harmonic tone |
| CCycleObservation | One cycle of a decaying quasi-sinusoid |
| CCycleTrackOptions | Options for track_cycles |
| CCycleTrack | Time-resolved track of one note |
| CAr2Observation | One short-window AR(2) pole fit |
| CAr2TrackOptions | Options for track_ar2 |
| CAr2Track | AR(2) pole track — an independent cross-check on track_cycles |
| CModalExtractionOptions | |
| CModalExtractionCandidate | |
| CModalExtractionResult | |
| CPitchEstimate | A single fundamental-frequency estimate |
| CPitchOptions | Options for estimate_pitch |
| CPitchTrackPoint | One point on an f0(t) trajectory: the frame's center time and its estimate |
| CPitchTrackOptions | Options for track_pitch |
| CPitchTrack | An f0(t) trajectory extracted from a render — the demodulator output the drift/jitter statistics consume |
| Ntooling | |
| Ngpu_health | Bounded, typed evidence returned by Pulp GPU health diagnostics |
| CHealthProvider | Blocking producer interface for the three independent GPU health probes |
| CHealthProbeOptions | Fault controls applied after real GPU work completes |
| CReferenceHost | |
| CStartupBudget | Versioned interpretation contract for startup measurements |
| CStartupCorrelation | |
| CStartupCapture | |
| CStartupIdentity | |
| CStartupTrial | |
| CStartupMeasurements | |
| CHealthReadResult | Closed response returned by dev.pulp.gpu/health.read@1 |
| CAdapterIdentity | Native adapter identity. Missing optional fields represent absent evidence |
| CProbeMeasurements | Optional measurements produced by one probe |
| CEvidenceEvent | One globally ordered stage observation with a registered diagnostic code |
| CProbeEvidence | Evidence and aggregate verdict for one independently executed probe |
| CHealthResult | Closed versioned aggregate returned by the GPU health diagnostic |
| Ngpu_probe | Bounded recipe definitions, owned evidence, and native GPU probe runs |
| CDprMeasurementRequest | |
| CFidelityRoi | |
| CDprMeasurementDisposition | |
| CAdapterIdentity | Native adapter identity. Missing optionals represent absent evidence |
| CDimensions | Recipe dimensions in pixels and unitless dispatched work items |
| CTolerance | Absolute and relative error limits in the recipe's numeric sample units |
| CRecipeBounds | Per-recipe caps for owned samples and artifact bytes |
| CRecipeDefinition | Borrowed process-lifetime definition of one deterministic recipe |
| CPassResult | One ordered semantic oracle result |
| CArtifact | Bounded artifact descriptor; payload bytes are owned by ArtifactPayload |
| CProbeResult | Closed v1 metadata and verdict for one recipe execution |
| CArtifactPayload | Owning artifact descriptor plus its exact payload bytes |
| CRunOptions | Options that bind one native recipe execution and its negative control |
| CRecipeRun | Owning recipe result and byte-exact artifact payloads |
| Ninspect | |
| Ndetail | |
| CTraceControlInventorySelection | |
| CStandaloneControlAuthorHooks | |
| CInspectorAgentContext | Host-owned snapshot returned by Inspector.getAgentContext |
| CInspectorAgentContextSource | Composition seam for host state that does not belong in protocol dispatch |
| CAgentRequest | One queued request from the human, with the context the agent needs to act without guessing which design/screen/state it refers to |
| CAudioConfig | Audio configuration snapshot |
| CMidiLogEntry | A single MIDI event for logging |
| CBufferUnderrun | Buffer underrun event |
| CChannelLevels | Per-channel audio levels |
| CAudioRuntimeTelemetry | Cheap runtime telemetry bridge for agent/UI polling |
| CAudioInspector | Monitors audio thread performance and state for the inspector |
| CInspectorAuditEntry | Metadata-only record for a mutating inspector request |
| CInspectorAuditLog | |
| CControlSecurityAuditEntry | Metadata-only security event |
| CControlSecurityAuditLog | |
| CInspectorAuthChallenge | |
| CInspectorAuthVerifier | One-shot verifier for a server-issued nonce |
| CInspectorMethodDescriptor | |
| CInspectorCapabilityDescriptor | |
| CInspectorCapture | |
| CInspectorCaptureSource | Host-owned image source |
| CInspectorClientTarget | Exact selector for one canonical control registration generation |
| CInspectorClientResult | Typed outcome for a one-shot canonical control request |
| CConsoleCapture | Captures JS console output (console.log/warn/error) for inspector display |
| CEntry | A captured log entry |
| CControlAdmissionRequest | |
| CControlAdmissionPlan | Immutable authority snapshot minted by ControlBroker after all seven permission terms pass |
| CControlAdmissionResult | |
| CControlAdmissionPolicy | Trusted, bounded, non-blocking broker-side evaluators for the three dynamic permission terms not owned by identity, manifest, or grant state |
| CControlArtifactLineage | |
| CControlArtifactProperties | |
| CControlArtifactMetadata | |
| CControlArtifactStoreConfig | |
| CControlArtifactDeletionRecord | Persisted deletion evidence intentionally excludes client-provided content, paths, consent text, and plugin metadata |
| CControlArtifactCollectionResult | |
| CControlArtifactStoreResult | |
| CControlArtifactReadResult | |
| CControlArtifactStore | Broker-owned content-addressed artifact persistence |
| CControlBrokerConfig | |
| CControlBrokerLifecycleResult | |
| CControlBroker | Dormant composition root for the local capability-control broker |
| CControlEndpointIdentity | Filesystem identity captured for an owner-private local socket endpoint |
| CControlTransportDispatchResult | |
| CControlClientTransport | One authenticated, connection-bound capability-control session |
| CControlDispatchResult | |
| CControlClient | Typed capability-control client over one connection-bound transport |
| CControlClientConnectionConfig | |
| CControlClientConnection | Concrete OS-local transport for one authenticated control session |
| CControlClientConnectionPrincipal | |
| CControlHostConnectionPrincipal | |
| CControlConnectionAdmission | |
| CControlConnectionAdmissionTicket | |
| CControlConnectionAdmissionResult | |
| CControlConnectionAdmissionStoreConfig | |
| CControlConnectionAdmissionStore | Broker-owned, process-local admission registry for authenticated carriers |
| CControlConsentPrompt | |
| CControlBrokerConsentAuthorityConfig | |
| CControlBrokerConsentAuthority | Process-local production consent authority |
| CControlEndpointEnrollmentContext | Explicit injection seam for endpoint-owned enrollment |
| CControlTrustedHostManagementLaunchResult | |
| CControlTrustedHostManagement | |
| CControlEndpointConfig | |
| CDurableClientPrincipal | Maps an already-authorized, kernel-observed peer to a broker-owned reconnectable principal |
| CControlEndpoint | OS-local carrier for one ControlService composition root |
| CControlExecutionOutcome | |
| CControlArtifactPublication | |
| CControlExecutionContext | |
| CControlOperationExecutorSlot | One-time late binding for a host operation executor |
| CControlGpuHealthProvider | UI-thread producer for the immutable snapshot consumed by dev.pulp.gpu/health.read@1 |
| CReferenceHost | |
| CConfig | |
| CAdapterIdentity | |
| CFrameObservation | |
| CControlGpuHealthReadSource | Exact-instance source for a bounded GPU startup-health snapshot |
| CControlGpuHealthViewAdapter | Pulp-owned UI-thread bridge from a concrete Standalone/plugin/constrained host to ControlGpuHealthProvider |
| CConfig | |
| CControlGrantId | |
| CControlConsentDecision | |
| CControlGrantRequest | |
| CControlGrantConsentRequest | Consent input assembled only after the broker has authenticated the client and resolved an exact live registration and selector |
| CControlGrant | |
| CControlGrantResult | |
| CControlOperationAuthorization | |
| CControlGrantStoreConfig | |
| CControlGrantStore | Stores only the client_granted term of the permission equation |
| CControlBrokerHealth | |
| CControlHealthProbeConfig | |
| CControlBrokerHealthProbeResult | |
| CControlHostBootstrapDiagnostics | |
| CControlHostBootstrapRecord | One-shot inherited authority material |
| CControlHostBootstrapBytes | |
| CControlHostConnectionConfig | |
| CControlHostConnection | Authenticated host-role carrier over the canonical ControlEnvelope stream |
| CControlUiObservationRequest | |
| CControlUiObservation | |
| CControlDiagnosticItem | |
| CControlLogEntry | |
| CControlLogPage | |
| CControlTestNoteInput | |
| CControlTestTransportInput | |
| CControlAuthoringChanges | |
| CControlAuthoringApplyResult | |
| CControlHostDevelopmentBinding | |
| CControlHostDevelopmentExecutorConfig | |
| CControlHostDevelopmentExecutor | Canonical host-main composition for bounded development outcomes that do not belong to state, capture, Motion, telemetry, or runtime evaluation |
| CControlHostEnrollmentTicket | |
| CControlHostEnrollmentResult | |
| CControlHostEnrollmentPlan | Move-only broker plan binding one consumed immutable launch snapshot to the exact preobserved process the broker launched |
| CControlHostEnrollmentStoreConfig | |
| CControlHostEnrollmentStore | Bounded, process-local enrollment registry |
| CControlHostObservabilityBinding | |
| CControlHostObservabilityBundleConfig | |
| CControlHostObservabilityBundle | Registration-scoped canonical trace and telemetry executor bundle |
| CControlHostPreflightDiagnostics | |
| CControlHostRouter | Dormant broker-to-host route selector |
| CControlUiExactTarget | A node name is never authority by itself |
| CControlUiAuthorityOwner | Broker-owned opaque authority owner for UI state retained between receipts |
| CControlUiProjectedAuthority | Live broker authority projected to the exact enrolled host |
| CControlUiPointerInput | |
| CControlUiKeyboardInput | |
| CControlUiFocusInput | |
| CControlUiTextInput | |
| CControlHostUiTargetAdapter | Pulp-owned composition seam for an ordinary Standalone view tree |
| CControlHostUiBinding | |
| CControlHostUiExecutorConfig | |
| CControlHostUiExecutor | Canonical exact-instance adapter for screenshot capture, bounded UI input, and explicitly unsafe research evaluation |
| CControlBrokerId | |
| CControlClientId | |
| CControlRegistrationId | |
| CControlPeerEvidence | Evidence observed by the local IPC carrier |
| CVerifiedControlPeerIdentity | Copyable proof minted only by the broker's trusted OS peer verifier |
| CControlPeerVerifier | Converts carrier-observed process evidence into an unforgeable-by-payload identity |
| CControlBootstrapSecret | Move-only bootstrap material. Destruction wipes the secret bytes |
| CControlBootstrapTicket | |
| CControlBootstrapResult | |
| CControlClientIdentity | |
| CControlClientResult | |
| CControlRegistrationRequest | |
| CControlRegistration | |
| CControlRegistrationResult | |
| CControlIdentityRegistryConfig | |
| CControlIdentityRegistry | Broker-owned identity state |
| CInspectorControlSession | Authority material returned by an enrollment-aware client integration |
| CInspectorControlSessionOpener | Injected enrollment/session boundary for canonical Inspector operations |
| CControlInstalledHostUiTargets | |
| CControlInstalledHostUiConfig | |
| CControlInstalledHostDevelopmentConfig | |
| CControlInstalledHostConfig | |
| CControlInstalledHost | Production ownership seam for one broker-launched installed T1 host |
| CControlMainThreadExecutor | Adapts typed control execution onto the completion-carrying Inspector main thread RPC without creating another queue or transport |
| CControlManifest | |
| CControlManifestDiagnostics | |
| CControlManifestValidation | |
| CControlArtifactExpectation | |
| CControlArtifactValidation | |
| CControlArtifactResultBinding | A frozen Product A operation contract |
| CControlReceiptResultBinding | Binds a typed success-result field to the broker-minted durable receipt |
| CControlOperationDescriptor | |
| CControlPermissionInputs | Inputs to the canonical permission equation |
| CControlPermissionDecision | |
| CControlMotionTarget | Exact T1 host state resolved after canonical admission |
| CControlMotionExecutorConfig | |
| CControlMotionExecutor | Executes dev.pulp.trace/control@1 without invoking the deleted Motion RPC transport |
| CControlOfflineRenderSource | Owned, transport-independent input resolved by a trusted T0 launcher from the request's opaque input artifact ID |
| CControlReceiptId | |
| CControlAuthorityBinding | Canonical immutable snapshot of the authority under which an operation was admitted |
| CControlOperationBinding | The complete idempotency scope for one admitted operation |
| CControlOperationResult | |
| CControlOperationReceipt | |
| CControlOperationStoreResult | |
| CControlOperationStoreConfig | |
| CControlOperationStore | Durable broker operation receipt and idempotency ledger |
| CControlPeerExpectation | Exact broker-owned peer expectation |
| CControlProtocolRange | |
| CControlNegotiationOffer | |
| CControlNegotiationResult | |
| CControlRequestEnvelope | |
| CControlCancelEnvelope | |
| CControlProgressEnvelope | A bounded progress observation for one admitted operation |
| CControlSessionOpenEnvelope | |
| CControlSessionOpenResult | |
| CControlManagementEnvelope | Finite broker-management family used by installed control adapters |
| CControlManagementResult | |
| CControlHostOpenEnvelope | |
| CControlHostOpenResult | |
| CControlHostReadyEnvelope | |
| CControlHostReadyResult | |
| CControlHostHeartbeatEnvelope | |
| CControlHostHeartbeatResult | |
| CControlHostPreflightChallengeEnvelope | |
| CControlHostPreflightResponseEnvelope | |
| CControlHostPreflightBootstrapEnvelope | |
| CControlHostPreflightReceiptEnvelope | |
| CControlHostExecuteEnvelope | Broker-to-host execution request |
| CControlHostAuthorityEndEnvelope | |
| CControlHostProgressEnvelope | |
| CControlHostCancelEnvelope | |
| CControlArtifactReadEnvelope | |
| CControlArtifactWireMetadata | Flattened, bounded wire representation of artifact metadata |
| CControlArtifactReadResponseEnvelope | |
| CControlHealthEnvelope | |
| CControlHealthResult | |
| CControlErrorEnvelope | |
| CControlHostArtifactPublication | Host-authored execution outcome |
| CControlHostCompleteEnvelope | |
| CControlArtifactHandle | |
| CControlReceiptEnvelope | |
| CControlLegacyInspectorError | Lossless compatibility detail for a failed operation declared with the legacy-inspector-json-v1 adapter encoding |
| CControlEnvelope | |
| CControlProtocolDiagnostics | |
| CControlJsonSchemaDiagnostics | |
| CControlSampleRegionGeneration | The host shares this authority with every topology publication for one graph |
| CControlSampleRegionTarget | |
| CControlSequencerStateTarget | Exact live sequencer channel resolved only after broker admission |
| CControlSequencerTransportTarget | The exact live transport an admitted registration may observe and edit |
| CControlServiceResult | |
| CControlServiceConfig | |
| CControlService | Dormant typed dispatcher over the broker composition root |
| CSession | Carrier-owned state for exactly one authenticated local connection |
| CControlStandaloneUiAdapterConfig | |
| CControlStandaloneUiAdapter | Ordinary Standalone implementation of the Pulp-owned UI adapter seam |
| CControlStateReadSource | A legal-thread view of one exact runtime's StateStore |
| CControlStateWriteTarget | Exact T1/T2a mutable state resolved only after broker admission |
| CControlTelemetryAuthority | |
| CControlTelemetrySubscriptionRequest | |
| CControlTelemetryChannelSample | |
| CControlTelemetryFrame | |
| CControlTelemetryTapConfig | |
| CControlTelemetryTap | Canonical transport-free, bounded fan-out telemetry tap |
| CControlTimelineDocumentSessionRequest | One decoded document-session request, already validated against the operation's input schema and the broker's writer-profile policy |
| CControlTimelineDocumentSessionOutcome | One typed outcome from the bound timeline::DocumentSession |
| CControlTimelineDocumentSessionSource | Exact-instance source for one live mutable Timeline document session |
| CControlTraceSessionExecutorConfig | |
| CControlTraceSessionExecutor | Executes the canonical trace-session operation through the existing process-global tracing owner on the registered host main thread |
| CControlTrustedHostLaunchIntent | |
| CControlTrustedHostInventoryConfig | |
| CControlTrustedHostInventoryTicket | |
| CControlTrustedHostInventoryPrepareResult | |
| CControlTrustedHostStaticExpectation | Exact static-code expectation derived from the staged destination |
| CControlTrustedHostRuntimeDependencyPolicy | |
| CControlTrustedHostPreparationPolicy | |
| CControlTrustedHostSnapshot | Immutable broker-owned launch material |
| CControlTrustedHostInventory | Process-local snapshot store intended to be owned by the broker composition root |
| CControlTrustedHostLauncherConfig | |
| CControlTrustedHostLaunchResult | |
| CControlTrustedHostLauncher | Broker composition seam for one inventory-approved raw host executable |
| CDomainHandler | Handles inspector protocol requests by delegating to the appropriate inspector component |
| CInspectorConfig | Inspector runtime configuration |
| CEffectiveEditorUrl | Compute the effective template and its source given the supplied config |
| CInspectorRequestContext | Authenticated transport identity attached to a domain request |
| CInspectorOverlay | |
| CReparentSourceEdit | Structural reparent → lock-to-source |
| CKnobApplyEdit | |
| CAgentRequestEdit | Send-to-agent → free-text request |
| CKnobHit | One knob control's on-screen hit-rect from the last paint |
| CPassAttribution | Aggregated attribution data for a single render pass type, computed over the rolling frame history |
| CReconcileRow | One classified tweak row in the reconciliation report |
| CReconcileReport | Aggregate reconciliation report over every tweak in the attached TweakStore, classified against the current live view tree |
| CBadgePlacement | Computed top-left placement for a selection badge (the type W×H hover tooltip and the grid-refuse "can't move" badge) |
| CCollapsableSection | A disclosure-triangle section: click header to expand/collapse content |
| CConsoleEntryView | Displays a single console log entry with colored level badge and timestamp |
| CInspectorWindow | Main tabbed inspector panel with four tabs: Elements | Console | Performance | State |
| CInspectorMainThreadRpc | Bounded response-after-apply handoff from an inspector transport thread to the registered host main thread |
| CConfig | |
| CMotionGeometryMetric | |
| CMotionScrollMetric | |
| CMotionTraceSpec | |
| CMotionTraceAttachResult | |
| CMotionInspector | |
| CMotionScrubber | |
| CInspectorMessage | A single inspector protocol message (request, response, or event) |
| CRuntimeEvaluatorCapabilities | |
| CRuntimeEvaluationResult | |
| CRuntimeEvaluator | Host-injected arbitrary-execution boundary |
| CInspectorPolicyConfig | |
| CInspectorAccessPolicy | Resolves named profiles and exact custom grants against capabilities that the host actually attached |
| CInspectorControllerScopeEnd | |
| CInspectorControllerLease | One-controller lease for mutating inspector operations |
| CEndedScope | |
| CInspectorSessionInfo | |
| CInspectorSession | Capability-enforcing dispatch facade |
| CInspectorSkpCapture | |
| CSkpCaptureSource | Host-owned serialized-frame source |
| CSourceJumpResult | Outcome of a source-jump resolution |
| CStateInspector | Monitors StateStore parameters for the inspector |
| CParamSnapshot | Parameter snapshot for display |
| CParamChange | Recent change entry |
| CMidiTestInput | |
| CStandaloneTransportTestInput | |
| CTestInputApplyResult | |
| CInspectorTestInputSource | |
| CTestInputDomain | |
| CTraceOwnerLease | |
| CTracePublicationOwner | |
| CTraceInspector | Handles Trace.* protocol requests by driving pulp::runtime::Tracing |
| CTweakStore | In-memory record of inspector direct-manipulation edits ("tweaks"), keyed by stable_anchor_id + dotted property path (e.g |
| CRecord | A single tweak record returned by list_tweaks() |
| CBatchEntry | One (property_path, value) pair within a batched apply |
| CDiskResult | Outcome of a disk operation |
| CDriftedTweak | One drifted tweak — a stored edit that no longer maps cleanly to the current design |
| CDriftReport | Three-way classification of every stored tweak against a design |
| CDesignSnapshot | A design snapshot the drift logic diffs tweaks against |
| CValueChannelTelemetryBroker | Transport-independent reader and bounded fan-out owner for value-channel telemetry |
| CConfig | |
| Nstd | STL namespace |
| Chash< pulp::canvas::FontOptions > | |
| Chash< pulp::canvas::FontScopeId > | |
| Chash< pulp::runtime::Uuid > | |
| Chash< pulp::runtime::ObjectId > | |
| Chash< pulp::runtime::SessionId > | |
| Chash< pulp::runtime::RunId > | |
| Chash< pulp::runtime::CorrelationId > | |
| Chash< pulp::timeline::ItemId > | |
| Cdsp | |
| CMeta | |
| Cpulp_native_audio_bus_v1 | |
| Cpulp_native_audio_io_v1 | |
| Cpulp_native_bus_layout_v1 | |
| Cpulp_native_core_v1 | |
| Cpulp_native_descriptor_v1 | |
| Cpulp_native_host_services_v1 | |
| Cpulp_native_midi_event_v1 | |
| Cpulp_native_midi_view_v1 | |
| Cpulp_native_param_event_v1 | |
| Cpulp_native_param_event_view_v1 | |
| Cpulp_native_param_v1 | |
| Cpulp_native_prepare_v1 | |
| Cpulp_native_process_context_v1 | |
| Cpulp_native_process_v1 | |
| Cpulp_native_state_out_v1 | |
| Cpulp_native_state_span_v1 | |
| Cpulp_node_audio_v1 | |
| Cpulp_node_descriptor_v1 | |
| Cpulp_node_entry_v1 | |
| Cpulp_node_host_services_v1 | |
| Cpulp_node_prepare_v1 | |
| Cpulp_node_writer_v1 | |
| CPulpIosAudioSessionEvent | |
| CUI | |
1.15.0