pulp::host Namespace Reference

Bounded event contracts shared by host ingress and graph-authored nodes. More...

Namespaces
namespace	detail
namespace	catalog
namespace	forge_lofi
namespace	forge_catalog
namespace	character_delay
namespace	distortion
namespace	forge_drum
namespace	dynamics
namespace	modulation
namespace	eurorack
namespace	forge_fdn
namespace	fuzz
namespace	forge_modulation
namespace	multiband
namespace	pitch
namespace	saturator
namespace	sequencing
namespace	sidechain
namespace	space
namespace	synthesis
namespace	tape
namespace	wavetable

Classes
struct	AnticipationEligibility
class	AnticipationLane
struct	AnticipationBoundary
struct	AnticipationPartition
struct	AnticipationSubgraph
struct	AudioRouteInfo
class	AudioRouteCatalog
	Control-thread source catalog supplied by a Pulp host (standalone, Forge, or another graph host). More...
class	MutableAudioRouteCatalog
	Small host-side implementation for standalone/Forge hosts. More...
class	CancelToken
	Shared cancel flag. More...
class	BackgroundScanner
struct	BakedPlan
struct	BakedTrust
struct	BakedCustomParamBinding
struct	LowerResult
struct	LowerabilityProof
struct	CustomNodeLifecycle
struct	BakedCustomNodeBinding
class	ParamInjector
class	BakedGraphProcessor
struct	BakedTypeRegistration
class	BakedTypeRegistry
struct	BakedPlanLoadResult
struct	BakePlanResult
struct	BoundedDelayDescriptor
struct	BoundedDelayRegistration
class	CrossfadePluginSlot
struct	CustomNodeDiagnosticHandle
struct	CustomNodeDiagnosticResult
struct	CustomNodeDiagnosticsDescriptor
struct	CustomNodeEventBlock
	The events visible to one Custom node for one block. More...
class	BakedParamView
struct	CustomNodeBakedParam
struct	CustomNodeType
struct	SampleKernelConfig
struct	PreparedSampleKernelConfig
struct	SampleKernelPrepareContext
struct	SampleFrameContext
struct	SampleKernelMetadata
struct	SampleKernelDescriptor
struct	CustomNodeTypeMetadata
struct	ForgeCatalogExportRealization
	One actually constructed realization. More...
struct	ForgeCatalogExportNode
	One machine-readable catalog family before JSON serialization. More...
struct	ForgeSampleRegionV1
	Exact v1 authoring routes. More...
struct	ForgeAuditFinding
struct	ForgeParamChoice
	One named state of a stepped parameter. More...
struct	ForgeAxisValue
	One value of a compile-time realization axis. More...
struct	ForgeParamDescriptor
struct	ForgeRealizationAxis
	A compile-time construction axis — a choice made when the node is built rather than automated afterwards. More...
struct	ForgeRealizationSetting
	One axis/value selection used to construct a concrete realization. More...
struct	ForgeRealization
	One concrete realization: the exact type_id a graph names, plus the axis settings that produced it. More...
struct	ForgeNodeDescriptor
struct	HostEventRecord
	One immutable host event in the graph's epoch-local sample domain. More...
class	HostEventIngress
	Fixed-capacity host ingress staging area. More...
struct	GraphAuthoredEvent
struct	GraphEventCounters
class	GraphAuthoredEventLane
	Explicit producer/consumer phases for a bounded, single-producer event lane. More...
struct	PortIdentityAlias
struct	PortIdentityIssue
struct	PortIdentityReport
struct	PortIdentityDiff
struct	PortIdentityUndo
struct	GraphLoadOptions
class	GraphSerializer
struct	GraphTimingDeclaration
struct	GraphTimingMeasurements
struct	GraphTimingEvidence
struct	ScanResult
class	IsolatedPluginScanner
struct	Vst3NativeHandle
struct	AudioUnitNativeHandle
struct	AudioUnitV3NativeHandle
struct	ClapNativeHandle
struct	Lv2NativeHandle
class	NativeHandleVisitor
struct	GeneratedDeviceAdmission
struct	NodePackEntry
struct	NodePackResource
struct	NodePackRuntimeRequirements
struct	NodePackManifest
struct	NodePackTrust
struct	NodePackHostPolicy
struct	NodePackLoadResult
class	VerifiedNodePackBinary
struct	NodePackVerifyResult
struct	OfflineSignalGraphConfig
	Prepare-time configuration for an offline SignalGraph render. More...
struct	OfflineSignalGraphOptions
	Per-render inputs. More...
struct	OfflineSignalGraphResult
	Result of an offline render. More...
class	OfflineSignalGraphHost
	Renders a SignalGraph offline at a fixed block size, using only the public SignalGraph API. More...
struct	PluginTypeIdentity
	CLAP-only type identity. Exact UTF-8 bytes; no name, path or normalization. More...
struct	PluginArtifactProvenance
	Executable-byte observation, not a portable release identity or signature. More...
class	PluginIdentityEvidence
	Immutable owned evidence. More...
struct	CanonicalPluginIdentity
struct	PluginSelection
struct	PluginResolvedIdentity
struct	ParamFlags
struct	HostParamInfo
class	PluginSlot
struct	PluginLoadResult
	Exactly one loaded slot or typed refusal. A successful slot owns its receipt. More...
struct	ProcessorTypeKey
struct	ProcessorRestoreDescriptor
	Application-owned, exact-version registration. More...
struct	ProcessorRestoreRecord
	Already decoded two-part state. More...
struct	RestoredProcessor
struct	ProcessorRestoreResult
class	ProcessorRestoreRegistry
	Control-thread building block for hosts restoring a set of Processor nodes. More...
class	ProcessorSignalGraphBinding
	Lifetime-bound access from a Processor instance to the SignalGraph it owns. More...
struct	SampleRegionPromotedParameter
struct	SampleRegionDefinition
struct	SampleRegionDescriptor
struct	SampleRegionResult
struct	SampleRegionParameterContractEntry
class	SampleRegionParameterContract
class	SampleRegionParameterBinding
class	SampleRegionParameterOwner
struct	PreparedSampleKernelBinding
struct	PreparedSampleRegionTransfer
struct	PreparedSampleRegionOperation
struct	PreparedSampleRegionPlan
struct	SampleRegionPlanResult
struct	SampleRegionConnection
struct	SampleRegionKernelNode
struct	SampleRegionKernelRegistryView
struct	SampleRegionLimits
struct	SampleRegionCandidate
struct	SampleRegionResourceStats
struct	SampleRegionProof
struct	SampleRegionGraphProof
struct	SampleRegionParserShape
struct	SampleRegionParserProof
struct	SampleRegionStateKey
class	SampleRegionStateCell
class	SampleRegionExecutionDomain
class	SampleRegionStateBank
struct	SampleRegionRuntimeReceipt
class	PreparedSampleRegion
struct	BlacklistEntry
class	ScanBlacklist
struct	ScanCacheEntry
class	HostScanCache
struct	PluginInfo
struct	ScanOptions
struct	ScanReport
class	PluginScanner
struct	GraphAuthoringReceipt
struct	Connection
struct	SignalGraphRouteCommand
	One typed mutation accepted by the host's canonical graph authority. More...
struct	SignalGraphRouteResult
class	SignalGraphControlAuthority
	The sole host-side authority for live graph modulation-route lifecycle. More...
class	SnapshotParameterIngressPasskey
	Passkey authorizing exact-generation parameter-event injection into a pinned ExecutionSnapshot. More...
struct	SignalGraphExecutionStatus
struct	ConnectionClass
struct	ExecutorTopologyValidation
struct	PluginRoutingScratch
struct	PluginBindingContext
struct	ParameterEventInjectionBinding
struct	CustomBindingContext
struct	SignalGraphExecutorRouting
struct	ExecutorSnapshotBinders
struct	PortHandle
struct	GraphResult
struct	RetainedHistoryPolicy
struct	NodeLiveSwapPolicy
struct	LiveSwapDiagnostics
struct	GraphNode
class	ExactParameterNodeClaimPasskey
	Passkey authorizing exact-parameter-event node claims on a prepared edit. More...
class	SignalGraph
struct	LiveSwapAdmission
struct	SubgraphNodeSpec
struct	SubgraphEdgeSpec
struct	SubgraphPortSpec
struct	SubgraphParameterSpec
struct	SubgraphChildSpec
struct	SubgraphTemplate
struct	SubgraphState
struct	SubgraphParameterBounds
struct	SubgraphInstance
struct	SubgraphExpansionResult
struct	SpectralInputPort
struct	SpectralOutputPort
struct	SpectralAnalysisPorts
struct	SpectralStagePorts
struct	SpectralSynthesisPorts
struct	BuiltInDeviceDescriptor
	One instantiable Pulp-owned device. More...
struct	TimelineDeviceGraphRoute
	One phase-1 track's lowering into the desktop SignalGraph adapter. More...
struct	TimelineTrackGraphRoute
struct	TimelineGraphBindingConfig
struct	TimelineGraphAdmission
	Structured admission result. More...
struct	TimelineGraphProcessResult
class	TimelineGraphPlaybackBinding
	Desktop adapter that lowers phase-1 timeline tracks into stable SignalGraph nodes. More...
struct	TimelineDeviceFreeGraph
struct	TimelineOfflineRenderConfig
	Prepare-time limits. More...
struct	TimelineOfflineRenderOptions
	One render request over a half-open tick region [start_tick, end_tick). More...
struct	TimelineOfflineRenderResult
	Result of a one-shot render. audio is populated only when code == Ok. More...
struct	TriggerPayload
struct	TriggerRecord
class	TriggerContext
struct	TriggerDetectorLane
struct	TriggerProducerConfig
struct	TriggerEnvelopeConfig
struct	TriggerAudioConfig
struct	TriggerEdge
struct	TriggerCounters
struct	TriggerResourceReport
class	PreparedTriggerPlan
struct	TriggerPreparation
struct	VoicePortKey
struct	VoiceIdentityKey
	Canonical authored identity for one template/bank/slot/path target. More...
struct	VoiceIdentityResult
struct	GraphRuntimeConnectionPlan
struct	GraphRuntimeConnectionSpec
struct	GraphRuntimeLimits
struct	GraphRuntimeNodePlan
struct	GraphRuntimeNodeSpec
struct	GraphRuntimePlan
struct	GraphRuntimePlanError
struct	GraphRuntimePlanResult
struct	GraphCommand
struct	GraphCommandTiming
struct	GraphEvent
struct	GraphMidiOutputEvent
struct	GraphRuntimeQueueStats
struct	GraphTimedCommand
class	QualifiedSpectralStage
	Closed catalog value. More...
class	SpectralIdentity
	Profile-one indexed channels: symmetric float Hann, local-window phase, forward scale one, inverse 1/N and full-overlap startup. More...

Typedefs
using	ScanProgressCallback
	Progress callback invoked from the worker thread.
using	ScanCompletionCallback
	Completion callback invoked when the scan finishes (or cancel lands).
using	ScanWorkerFn
	Worker signature: runs on the background thread.
using	CustomNodeEventProcessFn
	Stateless event-aware process callback.
using	CustomNodeInstanceEventProcessFn
	Stateful event-aware process callback.
using	CustomNodeProcessFn
using	CustomNodeParamProcessFn
using	CustomNodeTransportProcessFn
using	SampleKernelConstructFn
using	SampleKernelResetFn = void (*)(void* state) noexcept
using	SampleKernelDestroyFn = void (*)(void* state) noexcept
using	SampleKernelProcessFn
using	SampleDelayPublishFn
using	SampleDelayCommitFn
template<std::size_t CommandCapacity = 128, std::size_t EventCapacity = 256, std::size_t MidiOutputCapacity = 256>
using	GraphRuntimeQueues
using	ParameterEvent = ::pulp::state::ParameterEvent
using	ParameterEventQueue = ::pulp::state::ParameterEventQueue
using	ParamRate = state::ParamRate
using	SampleRegionId = std::uint32_t
using	SampleRegionKernelResolveFn
template<typename T>
using	SpectralResult = graph::SpectralResult<T>
using	TimelineDeviceSlotFactory = std::unique_ptr<PluginSlot> (*)(const PluginInfo&)
	Factory signature used by Timeline's disposable graph-lowering transaction.
using	NodeId
using	PortIndex

Enumerations
enum class	AnticipationExclusion : std::uint8_t {   None = 0 , LiveAudioInput , LiveMidiInput , Feedback ,   Sidechain , TransportSensitive , ExactParameterInput }
enum class	AudioRouteKind : std::uint8_t {   PhysicalInput , Track , Instrument , Bus ,   File , Internal }
enum class	LowerRejectReason {   None , NotPrepared , NotExecutorEligible , HostedPluginNotSelfContained ,   CustomNotYetLowerable , CustomNotLowerable , CustomTransportNotLowerable , NonAudioLaneNotLowerable ,   CodecRejected , StatefulCustomNotYetLoadable , ParameterContractMismatch , SpectralPersistenceUnsupported }
enum class	InjectStatus { Ok , PartialOverflow , InvalidHandle }
enum class	BoundedDelayKind : std::uint8_t { Integer , Fractional , MultiTap }
enum class	BoundedDelayInterpolation : std::uint8_t {   None , Linear , Lagrange3 , Lagrange5 ,   Thiran1 , Hermite4 }
enum class	BoundedDelayRefusalReason : std::uint8_t {   None , UnsupportedKind , UnsupportedInterpolation , InvalidDelayBounds ,   DelayOutOfBounds , InvalidTapCount , StateBudgetExceeded , ArithmeticOverflow ,   RegistrationRejected }
enum class	CustomNodeDiagnosticAvailability : std::uint8_t {   Available , Unsupported , MissingNode , StaleHandle ,   NotPrepared , Busy , SchemaMismatch }
enum class	CustomNodeDiagnosticConsistency : std::uint8_t { LiveApproximate , AudioCallerStopped }
enum class	SampleKernelCausality : std::uint8_t { Combinational = 0 , OneSampleDelay = 1 }
enum class	SampleKernelScope : std::uint8_t { RegionOnly = 0 }
enum class	SampleKernelConfigKind : std::uint8_t {   Invalid = 0 , None = 1 , BoundaryIndex = 2 , FiniteConstant = 3 ,   PromotedParameterId = 4 }
enum class	PreparedSampleKernelConfigKind : std::uint8_t {   Invalid = 0 , None = 1 , BoundaryIndex = 2 , FiniteConstant = 3 ,   PromotedParameterIndex = 4 }
enum class	ForgeAuditFault {   missing_catalog_node , unexpected_catalog_node , missing_realization , unexpected_realization ,   mismatched_type_id , duplicate_type_id , duplicate_axis , duplicate_realization ,   missing_axis_setting , unexpected_axis_setting , unknown_axis_value , undescribed_param ,   stale_descriptor , duplicate_key , duplicate_id , missing_choices ,   duplicate_choice , choices_on_continuous , choice_out_of_range , unknown_realization ,   empty_field , no_realizations }
enum class	ForgeParamKind { continuous , stepped }
	Whether a parameter sweeps continuously or selects among named states. More...
enum class	ForgeParamCurve { linear , logarithmic }
	How a value maps to its control travel. More...
enum class	HostEventResult : std::uint8_t {   Accepted , StaleEpoch , Unbound , OutOfRange ,   Late , Overflow , InvalidSequence , OutputCapacity ,   Busy }
enum class	GraphEventResult : std::uint8_t {   Accepted , StaleEpoch , Unbound , OutOfRange ,   Future , Late , Overflow , AttemptLimit ,   InvalidPhase , Busy }
enum class	GraphPluginScanMode { none , isolated_only , allow_in_process }
enum class	GraphTimingDisposition : std::uint8_t { Proven , Refused , Unsupported }
enum class	GraphTimingReason : std::uint8_t {   None , Unprepared , InvalidField , BlockCapacity ,   LatencyMismatch , SchedulingUnavailable , PartitionUnsupported , TailUnsupported ,   FractionalDelay , MultiTap , SemanticDelayUnmeasured , HostPdcUnmeasured ,   AlgorithmicLatencyUnmeasured , GroupDelayUnmeasured , MeasurementMismatch }
enum class	ScanStatus {   Ok , Crash , Timeout , FormatError ,   NotPlugin , WorkerMissing , ProtocolError }
	Outcome of an isolated scan attempt. More...
enum class	NativeHandleFormat {   Unknown , VST3 , AudioUnit , AudioUnitV3 ,   CLAP , LV2 }
enum class	GeneratedDevicePlatform : std::uint8_t { Desktop , Android , Ios , Web }
enum class	GeneratedDeviceArtifact : std::uint8_t {   DeclarativeGraph , InterpretedProgram , NativePack , WebAssembly ,   FrozenAudio , Recipe , GeneratedUi }
enum class	GeneratedDeviceOrigin : std::uint8_t { AppBundled , RuntimeDownloaded }
enum class	NodePackError {   Ok = 0 , ManifestInvalid = 1 , UntrustedSigner = 2 , BadSignature = 3 ,   HashMismatch = 4 , AbiMismatch = 5 , LoadFailed = 6 , SymbolMissing = 7 ,   UnsupportedRequirements = 8 , NodeMetadataMismatch = 9 , PlatformPolicyDenied = 10 , BinaryChanged = 11 }
enum class	PluginIdentityError {   unsupported_format , native_identity_missing , invalid_native_identity , identity_origin_unverified ,   descriptor_selection_missing , descriptor_selection_ambiguous , descriptor_enumeration_incomplete , plugin_load_failed ,   loaded_identity_mismatch }
enum class	PluginIdentityOrigin { authored_assertion , clap_descriptor }
enum class	PluginIdentityVerification { declared , loaded }
enum class	BypassSurface { none , parameter , unit_property }
enum class	ProcessorRestoreCode {   Restored , InvalidDescriptor , DuplicateProcessorType , InvalidRecord ,   StateLimitExceeded , UnknownProcessorType , ProcessorTypeDisallowed , UnsupportedVersion ,   ProcessorConstructionFailed , ProcessorInstanceNotFresh , ProcessorPortMismatch , ProcessorCapabilityMismatch ,   ProcessorStateRestoreFailed }
enum class	PreparedSampleRegionOperationKind : std::uint8_t { DelayPublish , Process , Transfer , DelayCommit }
enum class	SampleRegionConnectionLane : std::uint8_t {   PlainAudio , Midi , Event , Automation ,   AudioRateModulation , Sidechain }
enum class	SampleRegionRefusalReason : std::uint8_t {   None , UnknownRegion , UnknownMember , MemberInMultipleRegions ,   InvalidBoundary , InvalidBoundaryCrossing , InvalidProducerCardinality , DisconnectedMember ,   InvalidKernelConfig , UnsupportedNodeKind , SampleKernelOutsideRegion , UnresolvedSampleKernel ,   UnsupportedConnectionLane , LegacyFeedbackInRegion , CycleCrossesRegionBoundary , InstantaneousCycle ,   NonZeroCompensatableLatency , DuplicatePromotedParameter , ParameterContractMismatch , RegionLimitExceeded ,   NodeLimitExceeded , ConnectionLimitExceeded , DelayStateLimitExceeded , ParameterLimitExceeded ,   StateBudgetExceeded , BoundaryBufferBudgetExceeded , WorkBudgetExceeded , ArithmeticOverflow ,   PrepareFailed }
enum class	PluginFormat {   VST3 = 0 , AudioUnit = 1 , AudioUnitV3 = 2 , CLAP = 3 ,   LV2 = 4 , BuiltIn = 5 }
enum class	GraphAuthoringReceiptStatus : std::uint8_t { Current , WrongGraph , Stale }
enum class	AutomationMix : uint8_t { Replace = 0 , Add = 1 }
enum class	SignalGraphRouteResultCode : std::uint8_t {   Applied , EmptyBatch , DenseQueueOverflow , InvalidCommand ,   PrepareFailed , CommitFailed }
enum class	ExecutorTopologyValidationCode : std::uint8_t {   Accepted , TopologyIneligible , NodeLimitExceeded , ConnectionLimitExceeded ,   PerNodePortLimitExceeded , TotalPortLimitExceeded , PlanRejected }
enum class	NodeType {   AudioInput , AudioOutput , Plugin , Gain ,   MidiInput , MidiOutput , Custom , SpectralAnalysis ,   SpectralStage , SpectralSynthesis }
enum class	PortKind : uint8_t {   Audio , Sidechain , Midi , Event ,   Control , Param , Spectral }
enum class	LiveSwapCurve { Smoothstep , EqualPower }
enum class	RetainedHistoryMode : uint8_t {   Clear , Adopt , Crossfade , Reseed ,   Refuse }
	Policy for stateful DSP cells when a live instance is replaced. More...
enum class	LiveSwapFallbackReason : uint8_t {   None , NotOptedIn , LoadFailed , PrepareFailed ,   StateRestoreFailed , HistoryRefused , StateTooLarge , ShapeMismatch ,   LatencyChanged , EditorOpen , ParamContractMismatch , FeedbackNotSwappable ,   OverBudget , NoLoadHistory , PredicateExcluded , UntrustedIdentity }
enum class	BuiltInDeviceDomain { EventToEvent , EventToAudio }
	The domain a built-in Timeline device occupies in a track's device chain. More...
enum class	TimelineGraphAdmissionCode : std::uint8_t {   Accepted , InvalidConfiguration , DuplicateTrack , MissingTrack ,   MissingDestination , DestinationPortRange , IncompletePostDeviceRoute , MissingPostDeviceRoute ,   SourcePortRange , NodeLimitExceeded , ConnectionLimitExceeded , PerNodePortLimitExceeded ,   TotalPortLimitExceeded , RoutedPlanRejected , RoutedTopologyIneligible , GraphMutationFailed ,   GraphPrepareFailed , SampleRateMismatch , NoteCapacityExceeded , MissingDevicePlacement ,   UnexpectedDevicePlacement , DuplicateDevicePlacement , MissingDeviceNode , DeviceNodeNotPlugin ,   UnresolvedDevicePlugin , DuplicateDeviceNodeOwnership , UnknownAutomationParameter , ReadOnlyAutomationParameter ,   NonAutomatableAutomationParameter , DeviceNodeAutomationConflict , AutomationRendererRejected , RealtimeStretchRejected ,   CleanupRecoveryRequired , MissingProgramProject , ProgramProjectMismatch , MissingProgramSequence ,   UnsupportedDeviceChain , UnsupportedDevicePosition , UnsupportedDeviceSlotKind , UnsupportedDeviceKind ,   UnsupportedDeviceBinding , UnsupportedDeviceBypass , UnsupportedDeviceWetDry , UnsupportedDeviceState ,   MixedDeviceOwnership , DeviceFactoryFailed , EventDeviceLatencyUnavailable , EventDeviceLatencyOutOfRange ,   EventChainLiveInputUnsupported }
enum class	TimelineGraphProcessCode : std::uint8_t {   Ok , MissingProgram , InvalidTransport , NoteRenderFailed ,   AudioRenderFailed , RealtimeStretchGap , RealtimeStretchStateRequired , RealtimeStretchStalePublication ,   RealtimeStretchImpossibleRatio , RealtimeStretchBackpressure , RealtimeStretchUnderflow , RealtimeStretchUnsupportedScrubbing ,   CapacityExceeded , InputShapeMismatch , TopologyChanged , AutomationRenderFailed ,   AutomationDeliveryFailed , RoutedDispatchFailed , CleanupFailed , EventCompensationUnsupported }
enum class	TimelineDeviceFreeGraphCode : std::uint8_t { Ok , InvalidChannelCount , OutputNodeRejected }
enum class	TimelineOfflineRenderCode : std::uint8_t {   Ok = 0 , InvalidRange , InvalidLimits , SampleRateMismatch ,   InvalidProgram , BindingRejected , TransportRejected , ProcessFailed }
	Why a render did not produce audio. Ok is the only success value. More...
enum class	TriggerKind : std::uint8_t { Trigger = 1 }
enum class	TriggerEmitResult : std::uint8_t {   Accepted , StaleEpoch , Unbound , OutOfRange ,   Future , Late , Overflow , AttemptLimit ,   InvalidPhase }
enum class	TriggerAudioKind : std::uint8_t { Modulation , Lowpass }
enum class	TriggerGraphResult : std::uint8_t {   Accepted , Cardinality , Payload , UnsupportedProducer ,   Feedback , DependencyCycle , Mode , Budget ,   Binding , Frames , ClockExhausted , StaleGeneration ,   Busy , InvalidBuffers , ProcessingFailure }
enum class	VoicePortDirection : std::uint8_t { Input = 0 , Output = 1 }
enum class	VoicePortKind : std::uint8_t { Audio = 0 , Event = 1 , Control = 2 }
enum class	GraphRuntimeNodeKind
enum class	GraphRuntimePlanErrorCode
enum class	GraphCommandTimingType
enum class	GraphCommandType
enum class	GraphEventType
enum class	SpectralError

Functions
AnticipationEligibility	analyze_anticipation_eligibility (std::span< const GraphNode > nodes, std::span< const Connection > connections, std::span< const NodeId > exact_parameter_input_nodes={})
AnticipationPartition	build_anticipation_partition (std::span< const GraphNode > nodes, std::span< const Connection > connections, const AnticipationEligibility &eligibility)
AnticipationSubgraph	build_anticipation_subgraph (std::span< const GraphNode > nodes, std::span< const Connection > connections, const AnticipationPartition &partition)
std::vector< std::uint8_t >	write_baked_signed (const BakedPlan &plan, std::span< const std::uint8_t > private_key_64)
std::optional< BakedPlan >	verify_and_extract_plan (std::span< const std::uint8_t > bytes, const BakedTrust &trust)
LowerabilityProof	lowerability_of (std::span< const GraphNode > nodes, std::span< const Connection > connections, const std::function< const CustomNodeType *(std::string_view type_id, int version)> &resolve_custom={})
LowerResult	bake (const SignalGraph &graph)
LowerResult	load_baked (std::span< const std::uint8_t > bytes, const BakedTrust &trust, const std::vector< CustomNodeType > &custom_types)
BakedPlanLoadResult	load_baked_plan (std::span< const std::uint8_t > bytes, const BakedTrust &trust, const std::vector< BakedTypeRegistration > &registrations)
template<typename Registry> requires std::is_same_v<std::remove_cvref_t<Registry>, BakedTypeRegistry>
LowerResult	load_baked (std::span< const std::uint8_t > bytes, const BakedTrust &trust, Registry &&registry)
BakePlanResult	bake_to_plan (const SignalGraph &graph)
BoundedDelayRefusalReason	make_bounded_delay_registration (const BoundedDelayDescriptor &descriptor, BoundedDelayRegistration &registration)
BoundedDelayRefusalReason	register_bounded_delay (SignalGraph &graph, const BoundedDelayDescriptor &descriptor)
bool	sample_kernel_storage_is_disjoint (const SampleKernelDescriptor &descriptor, const void *state, const PreparedSampleKernelConfig &config, const SampleFrameContext &frame, const float *inputs, float *outputs) noexcept
const ForgeSampleRegionV1 *	forge_sample_region_v1 (std::string_view type_id) noexcept
	A legacy realization without an exact v1 route remains block-only.
std::vector< ForgeCatalogExportNode >	forge_catalog_export_nodes ()
	Build the semantic catalog projection used by both the CLI and the installed SDK snapshot.
std::vector< ForgeAuditFinding >	audit_forge_catalog_export (const std::vector< ForgeCatalogExportNode > &nodes)
	Audit descriptor/range joins and the independent expected-membership list.
std::vector< ForgeAuditFinding >	audit_catalog_export (const std::vector< ForgeCatalogExportNode > &nodes)
	Audit descriptor/range joins without imposing Forge's catalog membership.
std::string	serialize_forge_catalog_json (const std::vector< ForgeCatalogExportNode > &nodes)
const char *	forge_audit_fault_name (ForgeAuditFault fault)
std::vector< ForgeAuditFinding >	audit_forge_descriptor (const ForgeNodeDescriptor &descriptor, const std::vector< CustomNodeBakedParam > &baked, std::string_view realization_mode={})
	Audit one descriptor against the node it describes.
std::vector< ForgeAuditFinding >	audit_forge_catalog_membership (const std::vector< ForgeNodeDescriptor > &descriptors, const std::vector< std::string_view > &expected_node_keys)
	Prove that a projected export contains exactly the expected semantic nodes, each once.
std::string	describe_forge_audit_finding (const ForgeAuditFinding &finding)
	Human-readable one-line rendering, for a test failure or a CLI report.
const ForgeParamDescriptor *	find_param (const ForgeNodeDescriptor &node, std::string_view key) noexcept
	Look up a parameter descriptor by its stable key.
bool	param_applies (const ForgeParamDescriptor &param, std::string_view mode) noexcept
	True when param applies to the named realization mode.
bool	choice_applies (const ForgeParamChoice &choice, std::string_view mode) noexcept
HostEventResult	derive_mpe (std::span< const HostEventRecord > events, std::uint64_t block_start, midi::MpeVoiceTracker &tracker, midi::MpeBuffer &out) noexcept
	Convert projected records to the existing MPE sidecar.
HostEventResult	project_host_event_block (std::span< const HostEventRecord > records, std::uint64_t block_start, std::size_t frames, midi::MidiBuffer &midi_out, midi::MpeVoiceTracker *tracker=nullptr, midi::MpeBuffer *mpe_out=nullptr) noexcept
	Project an already-sorted absolute host-event block into the fixed MIDI, UMP, and optional MPE sidecars consumed by SignalGraph's existing ingress mailbox.
PortIdentityReport	validate_port_identities (std::span< const PortHandle > ports, std::span< const PortIdentityAlias > aliases={})
std::uint64_t	port_identity_fingerprint (std::span< const PortHandle > ports, std::span< const PortIdentityAlias > aliases={})
PortIdentityDiff	diff_port_identities (std::span< const PortHandle > before, std::span< const PortHandle > after, std::span< const PortIdentityAlias > aliases={})
PortIdentityUndo	capture_port_identity_undo (std::span< const PortHandle > before, std::span< const PortIdentityAlias > aliases={})
std::vector< PortHandle >	undo_port_identity (const PortIdentityUndo &undo)
GraphTimingEvidence	evaluate_graph_timing_contract (const SignalGraph &graph, const GraphTimingDeclaration &declaration, const GraphTimingMeasurements &measurements) noexcept
void *	create_editor_container (void *parent_window, uint32_t width, uint32_t height)
	Create a container view sized (width, height), inserted into parent_window's content view.
bool	editor_container_adopt_view (void *container, void *native_view, uint32_t width, uint32_t height)
	Insert an already-created native child view into container, sized to fill it and set to track the container's size.
void	resize_editor_container (void *container, uint32_t width, uint32_t height)
	Resize an existing container. No-op when container is null.
void	destroy_editor_container (void *container)
	Remove the container from its superview and release it. No-op when null.
double	editor_container_scale (void *parent_window)
	Backing scale factor of parent_window (2.0 on Retina), for the plugin's scale negotiation.
bool	normalize_authored_identity_text (std::string_view input, std::string &output)
	Normalize one authored identity segment to NFC UTF-8 and reject malformed, NUL-containing, or control-character input.
std::string	find_scan_worker (std::string_view explicit_path={})
	Locate the pulp-scan-worker binary for isolated scanning.
constexpr GeneratedDevicePlatform	build_generated_device_platform () noexcept
constexpr GeneratedDeviceAdmission	generated_device_admission (GeneratedDevicePlatform platform, GeneratedDeviceArtifact artifact, GeneratedDeviceOrigin origin) noexcept
	Returns the platform policy before any executable artifact is opened.
bool	parse_node_pack_manifest (const std::string &json, NodePackManifest &out)
std::vector< std::uint8_t >	node_pack_signed_message (const NodePackManifest &m)
NodePackVerifyResult	verify_node_pack_binary (const std::string &manifest_dir, const NodePackManifest &manifest)
NodePackLoadResult	load_verified_node_pack (VerifiedNodePackBinary binary, const NodePackManifest &manifest, const NodePackTrust &trust, const NodePackHostPolicy &policy)
NodePackLoadResult	load_node_pack (const std::string &manifest_dir, const NodePackManifest &manifest, const NodePackTrust &trust)
NodePackLoadResult	load_node_pack (const std::string &manifest_dir, const NodePackManifest &manifest, const NodePackTrust &trust, const NodePackHostPolicy &policy)
void	unload_node_pack (void *handle)
std::vector< PluginInfo >	scan_clap_bundle_descriptors (const std::string &path)
PluginLoadResult	load_clap_plugin_exact (const PluginSelection &selection)
std::optional< PluginIdentityError >	validate_plugin_type_identity (const PluginTypeIdentity &)
	Pure validation: nonempty, bounded UTF-8 without NUL or Unicode controls.
std::variant< CanonicalPluginIdentity, PluginIdentityError >	canonical_plugin_identity (const PluginIdentityEvidence &)
	Encodes only type identity; preserves evidence without increasing its trust.
std::string	serialize_plugin_identity_evidence (const PluginIdentityEvidence &)
	Unsigned serialized captures always import as declared, even if originally loaded.
std::optional< PluginIdentityEvidence >	parse_plugin_identity_evidence (std::string_view)
const char *	processor_restore_code_name (ProcessorRestoreCode code) noexcept
	Stable names for machine-readable diagnostics; messages are supplementary.
SignalGraphControlAuthority *	create_processor_signal_graph_authority (format::Processor &processor) noexcept
	Resolver used by the canonical standalone control host.
ProcessorSignalGraphBinding::Lease	create_processor_signal_graph_authority_lease (format::Processor &processor) noexcept
SampleRegionPlanResult	build_sample_region_plan (const SampleRegionCandidate &candidate)
bool	is_sample_region_v1_descriptor (const SampleKernelDescriptor &descriptor) noexcept
bool	sample_region_config_matches (const SampleKernelConfig &config, const SampleKernelDescriptor &descriptor) noexcept
SampleRegionProof	prove_sample_region (const SampleRegionCandidate &candidate)
SampleRegionGraphProof	prove_sample_regions (const std::vector< SampleRegionCandidate > &candidates)
SampleRegionParserProof	prove_sample_region_parser_shape (const SampleRegionParserShape &shape)
uint32_t	cap_clap_plugin_count (uint32_t count) noexcept
bool	plugin_info_from_au_identity (std::string_view identity, PluginInfo &info)
ConnectionClass	classify (const Connection &c)
bool	connection_affects_latency (const Connection &c)
ExecutorTopologyValidation	validate_signal_graph_executor_topology (std::span< const GraphNode > nodes, std::span< const Connection > connections, graph::GraphRuntimeLimits limits={})
void	reset_plugin_parameter_event_sequences (std::span< PluginBindingContext > contexts) noexcept
void	commit_plugin_parameter_event_sequences (std::span< PluginBindingContext > contexts) noexcept
bool	signal_graph_topology_executor_eligible (std::span< const GraphNode > nodes, std::span< const Connection > connections)
bool	signal_graph_executor_eligible (const SignalGraph &graph)
int	calculate_lowerable_graph_latency_samples (std::span< const GraphNode > nodes, std::span< const Connection > connections, const std::function< int(NodeId)> &custom_latency_for)
bool	build_executor_snapshot (std::span< const GraphNode > nodes, std::span< const Connection > connections, const ExecutorSnapshotBinders &binders, std::vector< PluginBindingContext > &plugin_ctx, PluginRoutingScratch &scratch, format::GraphRuntimeSnapshot &out, bool parallel_safe=false, std::vector< CustomBindingContext > *custom_ctx=nullptr)
bool	build_executor_snapshot (std::span< const GraphNode > nodes, std::span< const Connection > connections, const std::function< std::atomic< float > *(NodeId)> &gain_for, const std::function< PluginSlot *(NodeId)> &plugin_for, std::vector< PluginBindingContext > &plugin_ctx, PluginRoutingScratch &scratch, format::GraphRuntimeSnapshot &out, bool parallel_safe=false, const std::function< audio::AudioProcessLoadMeasurer *(NodeId)> &load_for={}, std::vector< CustomBindingContext > *custom_ctx=nullptr, const std::function< const CustomNodeProcessFn *(NodeId)> &custom_for={}, const std::function< const CustomNodeTransportProcessFn *(NodeId)> &custom_transport_for={}, const std::function< int(NodeId)> &plugin_latency_for={}, const std::function< const std::vector< HostParamInfo > *(NodeId)> &plugin_params_for={}, const std::function< ParameterEventInjectionBinding(NodeId)> &parameter_events_for={})
bool	build_signal_graph_executor_routing (const SignalGraph &graph, SignalGraphExecutorRouting &out)
NodeId	add_plugin_node_from_drop (SignalGraph &graph, const PluginInfo &info, bool *loaded_out=nullptr)
LiveSwapAdmission	evaluate_live_swap_admission (const audio::AudioProcessLoadSnapshot &graph, const std::vector< audio::AudioProcessLoadSnapshot > &staged_nodes, float headroom_threshold, std::uint64_t min_callbacks)
bool	register_builtin_sample_region_types (SignalGraph &graph)
bool	register_builtin_sample_region_types (SignalGraph::PreparedTopologyEdit &edit)
SubgraphExpansionResult	instantiate_subgraph (SignalGraph &graph, const SubgraphTemplate &definition, std::string instance_identity, std::uint32_t instance_index=0)
GraphResult	connect_subgraph_ports (SignalGraph &graph, const SubgraphInstance &source, std::string_view source_port, const SubgraphInstance &destination, std::string_view destination_port)
GraphResult	restore_subgraph_state (SignalGraph &graph, SubgraphInstance &instance, const SubgraphState &state)
std::span< const BuiltInDeviceDescriptor >	builtin_device_catalog () noexcept
	Every device load_builtin_plugin can instantiate, in chain order: an event-to-event device may precede an event-to-audio one, never follow it.
const BuiltInDeviceDescriptor *	find_builtin_device (std::string_view binding_key) noexcept
	The descriptor for binding_key, or nullptr when no built-in owns it.
std::unique_ptr< PluginSlot >	load_builtin_plugin (const PluginInfo &info)
	Loads a pathless Pulp-owned device. Unknown keys and non-empty paths fail closed.
int	event_device_latency_ceiling_samples () noexcept
	The per-chain event-compensation ceiling, in samples.
PluginInfo	builtin_device_plugin_info (const BuiltInDeviceDescriptor &descriptor)
	The PluginInfo the host uses to instantiate descriptor through the device factory.
TimelineDeviceFreeGraph	build_device_free_timeline_graph (SignalGraph &graph, const playback::PlaybackProgram &program, std::uint32_t output_channels)
	Adds a single output node to graph and returns one device-free route per track in program.
TimelineOfflineRenderResult	render_timeline_offline (SignalGraph &graph, TimelineGraphPlaybackBinding &binding, const playback::PlaybackProgram &program, std::span< const TimelineTrackGraphRoute > routes, const TimelineOfflineRenderConfig &config, const TimelineOfflineRenderOptions &options)
	Renders [start_tick, end_tick) of program through graph, plus a fixed tail, and returns deterministic Float32 audio.
VoiceIdentityResult	canonical_voice_identity (const VoiceIdentityKey &key)
	Encode and hash an authored identity using the G-4 v1 tagged, length-delimited wire form.
GraphRuntimePlanResult	build_graph_runtime_plan (std::span< const GraphRuntimeNodeSpec > nodes, std::span< const GraphRuntimeConnectionSpec > connections, GraphRuntimeLimits limits={})

Variables
constexpr std::size_t	kBakedMaxNodes = 512
constexpr std::size_t	kBakedMaxConnections = 2048
constexpr int	kBakedMaxPortsPerNode = 64
constexpr std::size_t	kBakedMaxTotalPorts = 4096
constexpr int	kBakedMaxBlock = 16384
constexpr std::size_t	kBakedMaxCustomTypeId = 256
constexpr std::size_t	kBakedMaxCustomState = 65536
constexpr std::size_t	kBakedMaxPlanBytes = 4u * 1024u * 1024u
constexpr int	kBakedPlanV1FormatVersion = 1
constexpr int	kBakedMaxSupportedFormatVersion = 2
constexpr int	kBakedPlanFormatVersion = kBakedMaxSupportedFormatVersion
constexpr std::size_t	kBakedMaxRegions = 16
constexpr std::size_t	kBakedMaxRegionMembers = 64
constexpr std::size_t	kBakedMaxRegionBoundaries = 8
constexpr std::size_t	kBakedMaxRegionParameters = 16
constexpr std::size_t	kBakedMaxRegionString = 1024
constexpr int	kBakedManifestSchemaVersion = 1
constexpr std::size_t	kBakedManifestMaxBytes = 4096
constexpr ForgeSampleRegionV1	kForgeSampleRegionV1 []
constexpr std::string_view	kBasicInstrumentBindingKey = "pulp.instrument.basic"
	Durable Timeline binding key for Pulp's pathless basic instrument.
constexpr std::string_view	kEventHumaniserBindingKey = "pulp.device.event.humanise"
	Durable Timeline binding key for Pulp's pathless look-ahead note humaniser.
constexpr int	kEventHumaniserWindowSamples = 512
	The humaniser's look-ahead window, in samples, and therefore the latency it reports.
constexpr std::uint32_t	kEventHumaniserTimingDepthParamId = 1
	Stable parameter IDs exposed by the built-in humaniser.
constexpr std::uint32_t	kEventHumaniserVelocityDepthParamId = 2
constexpr std::size_t	kAdmittedDeviceChainLength = 2
	The longest device chain the host binding lowers today.

Detailed Description

Bounded event contracts shared by host ingress and graph-authored nodes.

This header deliberately stops at the event boundary. Host records are projected into block-relative MIDI/UMP events and an MPE sidecar by the owner of the graph; they are not silently injected into SignalGraph's block-local MIDI mailbox. Graph-authored events use the same checked epoch/sample/sequence rules as the admitted trigger runtime, while keeping the producer and consumer phases explicit for future graph bindings.

Typedef Documentation

CustomNodeEventProcessFn

using pulp::host::CustomNodeEventProcessFn

Initial value:

 
    std::function<void(audio::BufferView<float>& output,
                       const audio::BufferView<const float>& input, int num_samples,
                       const CustomNodeEventBlock& events)>

Stateless event-aware process callback.

CustomNodeInstanceEventProcessFn

using pulp::host::CustomNodeInstanceEventProcessFn

Initial value:

 
    std::function<void(void* instance, audio::BufferView<float>& output,
                       const audio::BufferView<const float>& input, int num_samples,
                       const CustomNodeEventBlock& events)>

Stateful event-aware process callback.

The first argument is the instance returned by the type's create, exactly as process_instance receives it.

CustomNodeParamProcessFn

using pulp::host::CustomNodeParamProcessFn

Initial value:

 
    std::function<void(audio::BufferView<float>& output,
                       const audio::BufferView<const float>& input,
                       int num_samples,
                       const BakedParamView& params)>

CustomNodeProcessFn

typedef std::function< void(audio::BufferView< float > &output, const audio::BufferView< const float > &input, int num_samples)> pulp::host::CustomNodeProcessFn

Initial value:

 std::function<void(audio::BufferView<float>& output,
                                              const audio::BufferView<const float>& input,
                                              int num_samples)>

CustomNodeTransportProcessFn

typedef std::function< void(audio::BufferView< float > &output, const audio::BufferView< const float > &input, int num_samples, const format::ProcessContext &transport)> pulp::host::CustomNodeTransportProcessFn

Initial value:

 
    std::function<void(audio::BufferView<float>& output,
                       const audio::BufferView<const float>& input,
                       int num_samples,
                       const format::ProcessContext& transport)>

GraphRuntimeQueues

template<std::size_t CommandCapacity = 128, std::size_t EventCapacity = 256, std::size_t MidiOutputCapacity = 256>

using pulp::host::GraphRuntimeQueues

Initial value:

 
    ::pulp::graph::GraphRuntimeQueues<CommandCapacity, EventCapacity, MidiOutputCapacity>

NodeId

using pulp::graph::NodeId

ParameterEvent

using pulp::host::ParameterEvent = ::pulp::state::ParameterEvent

ParameterEventQueue

using pulp::host::ParameterEventQueue = ::pulp::state::ParameterEventQueue

ParamRate

using pulp::host::ParamRate = state::ParamRate

PortIndex

using pulp::graph::PortIndex

SampleDelayCommitFn

using pulp::host::SampleDelayCommitFn

Initial value:

 void (*)(void* state, const PreparedSampleKernelConfig& config,
                                     const float* inputs) noexcept

SampleDelayPublishFn

using pulp::host::SampleDelayPublishFn

Initial value:

 void (*)(const void* state, const PreparedSampleKernelConfig& config,
                                      float* outputs) noexcept

SampleKernelConstructFn

using pulp::host::SampleKernelConstructFn

Initial value:

 bool (*)(void* state,
                                         const SampleKernelPrepareContext& context) noexcept

SampleKernelDestroyFn

using pulp::host::SampleKernelDestroyFn = void (*)(void* state) noexcept

SampleKernelProcessFn

using pulp::host::SampleKernelProcessFn

Initial value:

 void (*)(void* state, const PreparedSampleKernelConfig& config,
                                       const SampleFrameContext& frame, const float* inputs,
                                       float* outputs) noexcept

SampleKernelResetFn

using pulp::host::SampleKernelResetFn = void (*)(void* state) noexcept

SampleRegionId

using pulp::host::SampleRegionId = std::uint32_t

SampleRegionKernelResolveFn

using pulp::host::SampleRegionKernelResolveFn

Initial value:

 const SampleKernelDescriptor* (*)(const void* context,
                                                                      std::string_view type_id,
                                                                      int version) noexcept

ScanCompletionCallback

using pulp::host::ScanCompletionCallback

Initial value:

 std::function<void(
    std::vector<PluginInfo> results, bool cancelled)>

Completion callback invoked when the scan finishes (or cancel lands).

cancelled == true means the worker observed a cancel before finishing.

ScanProgressCallback

using pulp::host::ScanProgressCallback

Initial value:

 std::function<void(
    const std::string& current_path, int scanned, int total)>

Progress callback invoked from the worker thread.

Callers should marshal to the UI thread before touching widgets.

ScanWorkerFn

using pulp::host::ScanWorkerFn

Initial value:

 std::function<std::vector<PluginInfo>(
    const CancelToken& token, const ScanProgressCallback& progress)>

Worker signature: runs on the background thread.

Must cooperatively check token.requested() between plugin inspections and return early when set. progress is optional.

SpectralResult

template<typename T>

using pulp::host::SpectralResult = graph::SpectralResult<T>

TimelineDeviceSlotFactory

using pulp::host::TimelineDeviceSlotFactory = std::unique_ptr<PluginSlot> (*)(const PluginInfo&)

Factory signature used by Timeline's disposable graph-lowering transaction.

Enumeration Type Documentation

AnticipationExclusion

enum class pulp::host::AnticipationExclusion : std::uint8_t

strong

Enumerator
None
LiveAudioInput
LiveMidiInput
Feedback
Sidechain
TransportSensitive
ExactParameterInput

AudioRouteKind

enum class pulp::host::AudioRouteKind : std::uint8_t

strong

Enumerator
PhysicalInput
Track
Instrument
Bus
File
Internal

AutomationMix

enum class pulp::host::AutomationMix : uint8_t

strong

Enumerator
Replace
Add

BoundedDelayInterpolation

enum class pulp::host::BoundedDelayInterpolation : std::uint8_t

strong

Enumerator
None
Linear
Lagrange3
Lagrange5
Thiran1
Hermite4

BoundedDelayKind

enum class pulp::host::BoundedDelayKind : std::uint8_t

strong

Enumerator
Integer
Fractional
MultiTap

BoundedDelayRefusalReason

enum class pulp::host::BoundedDelayRefusalReason : std::uint8_t

strong

Enumerator
None
UnsupportedKind
UnsupportedInterpolation
InvalidDelayBounds
DelayOutOfBounds
InvalidTapCount
StateBudgetExceeded
ArithmeticOverflow
RegistrationRejected

BuiltInDeviceDomain

enum class pulp::host::BuiltInDeviceDomain

strong

The domain a built-in Timeline device occupies in a track's device chain.

Deliberately not timeline::DeviceSlotKind: the catalog is consumed by tools that project it to CLI and MCP surfaces and must not drag the whole Timeline document model along with it.

Enumerator
EventToEvent
EventToAudio

BypassSurface

enum class pulp::host::BypassSurface

strong

Enumerator
none
parameter
unit_property

CustomNodeDiagnosticAvailability

enum class pulp::host::CustomNodeDiagnosticAvailability : std::uint8_t

strong

Enumerator
Available
Unsupported
MissingNode
StaleHandle
NotPrepared
Busy
SchemaMismatch

CustomNodeDiagnosticConsistency

enum class pulp::host::CustomNodeDiagnosticConsistency : std::uint8_t

strong

Enumerator
LiveApproximate
AudioCallerStopped

ExecutorTopologyValidationCode

enum class pulp::host::ExecutorTopologyValidationCode : std::uint8_t

strong

Enumerator
Accepted
TopologyIneligible
NodeLimitExceeded
ConnectionLimitExceeded
PerNodePortLimitExceeded
TotalPortLimitExceeded
PlanRejected

ForgeAuditFault

enum class pulp::host::ForgeAuditFault

strong

Enumerator
missing_catalog_node	an indexed semantic node is absent from the export
unexpected_catalog_node	an export node is absent from the canonical registry
missing_realization	a declared realization was not constructed for export
unexpected_realization	a constructed realization is absent from the descriptor
mismatched_type_id	a constructed node disagrees with its declared type id
duplicate_type_id	two concrete realizations register the same type id
duplicate_axis	two axes or two values on one axis share a stable key
duplicate_realization	two realizations share a stable mode
missing_axis_setting	a realization does not select every declared axis
unexpected_axis_setting	a realization selects an axis the node does not declare
unknown_axis_value	a realization selects an undeclared value for an axis
undescribed_param	the node bakes a parameter no descriptor names
stale_descriptor	a descriptor names a parameter the node no longer bakes
duplicate_key	two descriptors share a stable key
duplicate_id	two descriptors name the same parameter
missing_choices	stepped, but no named states
duplicate_choice	named states share a stable token or display label
choices_on_continuous	named states on a continuous sweep
choice_out_of_range	a named state's value is outside the baked range
unknown_realization	a realization_mode naming no declared realization
empty_field	key, label or description left blank
no_realizations	a node with no concrete realization to build

ForgeParamCurve

enum class pulp::host::ForgeParamCurve

strong

How a value maps to its control travel.

A log parameter whose control is linear feels dead across most of its range.

Enumerator
linear
logarithmic

ForgeParamKind

enum class pulp::host::ForgeParamKind

strong

Whether a parameter sweeps continuously or selects among named states.

Enumerator
continuous
stepped

GeneratedDeviceArtifact

enum class pulp::host::GeneratedDeviceArtifact : std::uint8_t

strong

Enumerator
DeclarativeGraph
InterpretedProgram
NativePack
WebAssembly
FrozenAudio
Recipe
GeneratedUi

GeneratedDeviceOrigin

enum class pulp::host::GeneratedDeviceOrigin : std::uint8_t

strong

Enumerator
AppBundled
RuntimeDownloaded

GeneratedDevicePlatform

enum class pulp::host::GeneratedDevicePlatform : std::uint8_t

strong

Enumerator
Desktop
Android
Ios
Web

GraphAuthoringReceiptStatus

enum class pulp::host::GraphAuthoringReceiptStatus : std::uint8_t

strong

Enumerator
Current
WrongGraph
Stale

GraphCommandTimingType

enum class pulp::graph::GraphCommandTimingType : std::uint8_t

strong

GraphCommandType

enum class pulp::graph::GraphCommandType : std::uint8_t

strong

GraphEventResult

enum class pulp::host::GraphEventResult : std::uint8_t

strong

Enumerator
Accepted
StaleEpoch
Unbound
OutOfRange
Future
Late
Overflow
AttemptLimit
InvalidPhase
Busy

GraphEventType

enum class pulp::graph::GraphEventType : std::uint8_t

strong

GraphPluginScanMode

enum class pulp::host::GraphPluginScanMode

strong

Enumerator
none
isolated_only
allow_in_process

GraphRuntimeNodeKind

enum class pulp::graph::GraphRuntimeNodeKind : std::uint8_t

strong

GraphRuntimePlanErrorCode

enum class pulp::graph::GraphRuntimePlanErrorCode : std::uint8_t

strong

GraphTimingDisposition

enum class pulp::host::GraphTimingDisposition : std::uint8_t

strong

Enumerator
Proven
Refused
Unsupported

GraphTimingReason

enum class pulp::host::GraphTimingReason : std::uint8_t

strong

Enumerator
None
Unprepared
InvalidField
BlockCapacity
LatencyMismatch
SchedulingUnavailable
PartitionUnsupported
TailUnsupported
FractionalDelay
MultiTap
SemanticDelayUnmeasured
HostPdcUnmeasured
AlgorithmicLatencyUnmeasured
GroupDelayUnmeasured
MeasurementMismatch

HostEventResult

enum class pulp::host::HostEventResult : std::uint8_t

strong

Enumerator
Accepted
StaleEpoch
Unbound
OutOfRange
Late
Overflow
InvalidSequence
OutputCapacity
Busy

InjectStatus

enum class pulp::host::InjectStatus

strong

Enumerator
Ok
PartialOverflow
InvalidHandle

LiveSwapCurve

enum class pulp::host::LiveSwapCurve

strong

Enumerator
Smoothstep
EqualPower

LiveSwapFallbackReason

enum class pulp::host::LiveSwapFallbackReason : uint8_t

strong

Enumerator
None
NotOptedIn
LoadFailed
PrepareFailed
StateRestoreFailed
HistoryRefused
StateTooLarge
ShapeMismatch
LatencyChanged
EditorOpen
ParamContractMismatch
FeedbackNotSwappable
OverBudget
NoLoadHistory
PredicateExcluded
UntrustedIdentity

LowerRejectReason

enum class pulp::host::LowerRejectReason

strong

Enumerator
None
NotPrepared
NotExecutorEligible
HostedPluginNotSelfContained
CustomNotYetLowerable
CustomNotLowerable
CustomTransportNotLowerable
NonAudioLaneNotLowerable
CodecRejected
StatefulCustomNotYetLoadable
ParameterContractMismatch
SpectralPersistenceUnsupported

NativeHandleFormat

enum class pulp::host::NativeHandleFormat

strong

Enumerator
Unknown
VST3
AudioUnit
AudioUnitV3
CLAP
LV2

NodePackError

enum class pulp::host::NodePackError

strong

Enumerator
Ok
ManifestInvalid
UntrustedSigner
BadSignature
HashMismatch
AbiMismatch
LoadFailed
SymbolMissing
UnsupportedRequirements
NodeMetadataMismatch
PlatformPolicyDenied
BinaryChanged

NodeType

enum class pulp::host::NodeType

strong

Enumerator
AudioInput
AudioOutput
Plugin
Gain
MidiInput
MidiOutput
Custom
SpectralAnalysis
SpectralStage
SpectralSynthesis

PluginFormat

enum class pulp::host::PluginFormat

strong

Enumerator
VST3
AudioUnit
AudioUnitV3
CLAP
LV2
BuiltIn	Pulp-owned, pathless device resolved without external discovery.

PluginIdentityError

enum class pulp::host::PluginIdentityError

strong

Enumerator
unsupported_format
native_identity_missing
invalid_native_identity
identity_origin_unverified
descriptor_selection_missing
descriptor_selection_ambiguous
descriptor_enumeration_incomplete
plugin_load_failed
loaded_identity_mismatch

PluginIdentityOrigin

enum class pulp::host::PluginIdentityOrigin

strong

Enumerator
authored_assertion
clap_descriptor

PluginIdentityVerification

enum class pulp::host::PluginIdentityVerification

strong

Enumerator
declared
loaded

PortKind

enum class pulp::host::PortKind : uint8_t

strong

Enumerator
Audio
Sidechain
Midi
Event
Control
Param
Spectral

PreparedSampleKernelConfigKind

enum class pulp::host::PreparedSampleKernelConfigKind : std::uint8_t

strong

Enumerator
Invalid
None
BoundaryIndex
FiniteConstant
PromotedParameterIndex

PreparedSampleRegionOperationKind

enum class pulp::host::PreparedSampleRegionOperationKind : std::uint8_t

strong

Enumerator
DelayPublish
Process
Transfer
DelayCommit

ProcessorRestoreCode

enum class pulp::host::ProcessorRestoreCode

strong

Enumerator
Restored
InvalidDescriptor
DuplicateProcessorType
InvalidRecord
StateLimitExceeded
UnknownProcessorType
ProcessorTypeDisallowed
UnsupportedVersion
ProcessorConstructionFailed
ProcessorInstanceNotFresh
ProcessorPortMismatch
ProcessorCapabilityMismatch
ProcessorStateRestoreFailed

RetainedHistoryMode

enum class pulp::host::RetainedHistoryMode : uint8_t

strong

Policy for stateful DSP cells when a live instance is replaced.

The policy is explicit so a replacement cannot silently attach a delay tail to a different algorithm or latency domain.

Enumerator
Clear
Adopt
Crossfade
Reseed
Refuse

SampleKernelCausality

enum class pulp::host::SampleKernelCausality : std::uint8_t

strong

Enumerator
Combinational
OneSampleDelay

SampleKernelConfigKind

enum class pulp::host::SampleKernelConfigKind : std::uint8_t

strong

Enumerator
Invalid
None
BoundaryIndex
FiniteConstant
PromotedParameterId

SampleKernelScope

enum class pulp::host::SampleKernelScope : std::uint8_t

strong

Enumerator
RegionOnly

SampleRegionConnectionLane

enum class pulp::host::SampleRegionConnectionLane : std::uint8_t

strong

Enumerator
PlainAudio
Midi
Event
Automation
AudioRateModulation
Sidechain

SampleRegionRefusalReason

enum class pulp::host::SampleRegionRefusalReason : std::uint8_t

strong

Enumerator
None
UnknownRegion
UnknownMember
MemberInMultipleRegions
InvalidBoundary
InvalidBoundaryCrossing
InvalidProducerCardinality
DisconnectedMember
InvalidKernelConfig
UnsupportedNodeKind
SampleKernelOutsideRegion
UnresolvedSampleKernel
UnsupportedConnectionLane
LegacyFeedbackInRegion
CycleCrossesRegionBoundary
InstantaneousCycle
NonZeroCompensatableLatency
DuplicatePromotedParameter
ParameterContractMismatch
RegionLimitExceeded
NodeLimitExceeded
ConnectionLimitExceeded
DelayStateLimitExceeded
ParameterLimitExceeded
StateBudgetExceeded
BoundaryBufferBudgetExceeded
WorkBudgetExceeded
ArithmeticOverflow
PrepareFailed

ScanStatus

enum class pulp::host::ScanStatus

strong

Outcome of an isolated scan attempt.

Anything non-Ok means the parent did NOT trust the worker's stdout — descriptor is only meaningful when status == Ok.

Enumerator
Ok	Worker exited 0 and emitted a parseable descriptor.
Crash	Worker terminated abnormally (signal / non-zero code with no JSON). The bundle is suspect — caller should blacklist it.
Timeout	Worker exceeded the per-scan timeout. Treated as a soft crash for blacklist purposes.
FormatError	Worker rejected the bundle (exit code 3 — extension not recognized). Not a crash; just unsupported.
NotPlugin	Worker ran cleanly but emitted no descriptor (the file at path was not a plugin we can scan).
WorkerMissing	The configured worker_path doesn't exist or can't be exec'd. Operational error, not a bundle problem.
ProtocolError	The worker exited 0 but its stdout could not be trusted: it exceeded the capture limit or a line did not parse. The worker owns that channel (the plugin's stdout is redirected to stderr before it loads), so this is a worker or transport fault, not the bundle's, and callers must not blacklist.

SignalGraphRouteResultCode

enum class pulp::host::SignalGraphRouteResultCode : std::uint8_t

strong

Enumerator
Applied
EmptyBatch
DenseQueueOverflow
InvalidCommand
PrepareFailed
CommitFailed

SpectralError

enum class pulp::graph::SpectralError : std::uint8_t

strong

TimelineDeviceFreeGraphCode

enum class pulp::host::TimelineDeviceFreeGraphCode : std::uint8_t

strong

Enumerator
Ok
InvalidChannelCount	output_channels was zero, or wider than the graph accepts.
OutputNodeRejected	The graph refused the output node.

TimelineGraphAdmissionCode

enum class pulp::host::TimelineGraphAdmissionCode : std::uint8_t

strong

Enumerator
Accepted
InvalidConfiguration
DuplicateTrack
MissingTrack
MissingDestination
DestinationPortRange
IncompletePostDeviceRoute
MissingPostDeviceRoute
SourcePortRange
NodeLimitExceeded
ConnectionLimitExceeded
PerNodePortLimitExceeded
TotalPortLimitExceeded
RoutedPlanRejected
RoutedTopologyIneligible
GraphMutationFailed
GraphPrepareFailed
SampleRateMismatch
NoteCapacityExceeded
MissingDevicePlacement
UnexpectedDevicePlacement
DuplicateDevicePlacement
MissingDeviceNode
DeviceNodeNotPlugin
UnresolvedDevicePlugin
DuplicateDeviceNodeOwnership
UnknownAutomationParameter
ReadOnlyAutomationParameter
NonAutomatableAutomationParameter
DeviceNodeAutomationConflict
AutomationRendererRejected
RealtimeStretchRejected
CleanupRecoveryRequired
MissingProgramProject
ProgramProjectMismatch
MissingProgramSequence
UnsupportedDeviceChain
UnsupportedDevicePosition
UnsupportedDeviceSlotKind
UnsupportedDeviceKind
UnsupportedDeviceBinding
UnsupportedDeviceBypass
UnsupportedDeviceWetDry
UnsupportedDeviceState
MixedDeviceOwnership
DeviceFactoryFailed
EventDeviceLatencyUnavailable	A device's backend cannot report latency, or asked and the plugin errored. The number is a placeholder rather than a fact, and treating an unanswered question as a confident zero is exactly what a delay proof would then certify, so admission fails closed instead.
EventDeviceLatencyOutOfRange	A device reported a negative latency, or one past the graph's declared per-node ceiling. actual carries the reported value and limit the ceiling.
EventChainLiveInputUnsupported	A track offers live input into an event chain that is compensated by reading ahead. Scheduled events can be issued early; a live note cannot, so the two would diverge by exactly the chain's event latency. The pair is refused until a per-track monitor policy defines what the musician hears.

TimelineGraphProcessCode

enum class pulp::host::TimelineGraphProcessCode : std::uint8_t

strong

Enumerator
Ok
MissingProgram
InvalidTransport
NoteRenderFailed
AudioRenderFailed
RealtimeStretchGap
RealtimeStretchStateRequired
RealtimeStretchStalePublication
RealtimeStretchImpossibleRatio
RealtimeStretchBackpressure
RealtimeStretchUnderflow
RealtimeStretchUnsupportedScrubbing
CapacityExceeded
InputShapeMismatch
TopologyChanged
AutomationRenderFailed
AutomationDeliveryFailed
RoutedDispatchFailed
CleanupFailed
EventCompensationUnsupported	A compensating event shift met a transport range that locates events by host beat rather than by document sample, so the shift has no origin to land on. It fails closed rather than silently dropping the shift. A read-ahead that runs past an enabled loop's end does NOT reach here: it is folded to the post-wrap content and plays.

TimelineOfflineRenderCode

enum class pulp::host::TimelineOfflineRenderCode : std::uint8_t

strong

Why a render did not produce audio. Ok is the only success value.

Enumerator
Ok
InvalidRange	Bounds were rejected before any work: end <= start, negative ticks, or a tick range whose sample derivation saturates the tempo map.
InvalidLimits	A limit was zero, negative, or exceeded (channels, block frames, or the caller's output-frame ceiling).
SampleRateMismatch	The request's sample rate disagrees with the program's compiled tempo map.
InvalidProgram	The program has no tracks, no tempo map, or no routes were supplied.
BindingRejected	TimelineGraphPlaybackBinding::prepare()/adopt failed; see admission.
TransportRejected	MasterTransport::prepare()/seek()/set_playing() failed; see transport_error.
ProcessFailed	A block failed mid-render; see process. The partial buffer is discarded.

TriggerAudioKind

enum class pulp::host::TriggerAudioKind : std::uint8_t

strong

Enumerator
Modulation
Lowpass

TriggerEmitResult

enum class pulp::host::TriggerEmitResult : std::uint8_t

strong

Enumerator
Accepted
StaleEpoch
Unbound
OutOfRange
Future
Late
Overflow
AttemptLimit
InvalidPhase

TriggerGraphResult

enum class pulp::host::TriggerGraphResult : std::uint8_t

strong

Enumerator
Accepted
Cardinality
Payload
UnsupportedProducer
Feedback
DependencyCycle
Mode
Budget
Binding
Frames
ClockExhausted
StaleGeneration
Busy
InvalidBuffers
ProcessingFailure

TriggerKind

enum class pulp::host::TriggerKind : std::uint8_t

strong

Enumerator
Trigger

VoicePortDirection

enum class pulp::host::VoicePortDirection : std::uint8_t

strong

Enumerator
Input
Output

VoicePortKind

enum class pulp::host::VoicePortKind : std::uint8_t

strong

Enumerator
Audio
Event
Control

Function Documentation

add_plugin_node_from_drop()

NodeId pulp::host::add_plugin_node_from_drop	(	SignalGraph &	graph,
		const PluginInfo &	info,
		bool *	loaded_out = nullptr )

analyze_anticipation_eligibility()

AnticipationEligibility pulp::host::analyze_anticipation_eligibility	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections,
		std::span< const NodeId >	exact_parameter_input_nodes = {} )

audit_catalog_export()

std::vector< ForgeAuditFinding > pulp::host::audit_catalog_export

(

const std::vector< ForgeCatalogExportNode > &

nodes

)

Audit descriptor/range joins without imposing Forge's catalog membership.

Provider-neutral catalog users may define their own node-key inventory.

audit_forge_catalog_export()

std::vector< ForgeAuditFinding > pulp::host::audit_forge_catalog_export

(

const std::vector< ForgeCatalogExportNode > &

nodes

)

Audit descriptor/range joins and the independent expected-membership list.

audit_forge_catalog_membership()

std::vector< ForgeAuditFinding > pulp::host::audit_forge_catalog_membership	(	const std::vector< ForgeNodeDescriptor > &	descriptors,
		const std::vector< std::string_view > &	expected_node_keys )

Prove that a projected export contains exactly the expected semantic nodes, each once.

The expected list is maintained independently of the projection so a dropped or orphan registration cannot silently produce a different, still-valid JSON document.

audit_forge_descriptor()

std::vector< ForgeAuditFinding > pulp::host::audit_forge_descriptor	(	const ForgeNodeDescriptor &	descriptor,
		const std::vector< CustomNodeBakedParam > &	baked,
		std::string_view	realization_mode = {} )

Audit one descriptor against the node it describes.

baked is the parameter list from one built CustomNodeType — the single source of numeric truth for the named realization. Catalog-level callers must audit every realization because ranges, defaults, and parameter presence may differ between them.

bake()

LowerResult pulp::host::bake

(

const SignalGraph &

graph

)

bake_to_plan()

BakePlanResult pulp::host::bake_to_plan

(

const SignalGraph &

graph

)

build_anticipation_partition()

AnticipationPartition pulp::host::build_anticipation_partition	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections,
		const AnticipationEligibility &	eligibility )

build_anticipation_subgraph()

AnticipationSubgraph pulp::host::build_anticipation_subgraph	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections,
		const AnticipationPartition &	partition )

build_device_free_timeline_graph()

TimelineDeviceFreeGraph pulp::host::build_device_free_timeline_graph	(	SignalGraph &	graph,
		const playback::PlaybackProgram &	program,
		std::uint32_t	output_channels )

Adds a single output node to graph and returns one device-free route per track in program.

The caller passes the routes to TimelineGraphPlaybackBinding::prepare(), which creates the per-track audio and mixer nodes and connects them to the returned output node.

build_executor_snapshot() [1/2]

bool pulp::host::build_executor_snapshot	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections,
		const ExecutorSnapshotBinders &	binders,
		std::vector< PluginBindingContext > &	plugin_ctx,
		PluginRoutingScratch &	scratch,
		format::GraphRuntimeSnapshot &	out,
		bool	parallel_safe = false,
		std::vector< CustomBindingContext > *	custom_ctx = nullptr )

build_executor_snapshot() [2/2]

bool pulp::host::build_executor_snapshot	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections,
		const std::function< std::atomic< float > *(NodeId)> &	gain_for,
		const std::function< PluginSlot *(NodeId)> &	plugin_for,
		std::vector< PluginBindingContext > &	plugin_ctx,
		PluginRoutingScratch &	scratch,
		format::GraphRuntimeSnapshot &	out,
		bool	parallel_safe = false,
		const std::function< audio::AudioProcessLoadMeasurer *(NodeId)> &	load_for = {},
		std::vector< CustomBindingContext > *	custom_ctx = nullptr,
		const std::function< const CustomNodeProcessFn *(NodeId)> &	custom_for = {},
		const std::function< const CustomNodeTransportProcessFn *(NodeId)> &	custom_transport_for = {},
		const std::function< int(NodeId)> &	plugin_latency_for = {},
		const std::function< const std::vector< HostParamInfo > *(NodeId)> &	plugin_params_for = {},
		const std::function< ParameterEventInjectionBinding(NodeId)> &	parameter_events_for = {} )

build_generated_device_platform()

GeneratedDevicePlatform pulp::host::build_generated_device_platform ( )

nodiscardconstexprnoexcept

build_graph_runtime_plan()

GraphRuntimePlanResult pulp::graph::build_graph_runtime_plan	(	std::span< const GraphRuntimeNodeSpec >	nodes,
		std::span< const GraphRuntimeConnectionSpec >	connections,
		GraphRuntimeLimits	limits = {} )

build_sample_region_plan()

SampleRegionPlanResult pulp::host::build_sample_region_plan

(

const SampleRegionCandidate &

candidate

)

build_signal_graph_executor_routing()

bool pulp::host::build_signal_graph_executor_routing	(	const SignalGraph &	graph,
		SignalGraphExecutorRouting &	out )

builtin_device_catalog()

std::span< const BuiltInDeviceDescriptor > pulp::host::builtin_device_catalog ( )

noexcept

Every device load_builtin_plugin can instantiate, in chain order: an event-to-event device may precede an event-to-audio one, never follow it.

builtin_device_plugin_info()

PluginInfo pulp::host::builtin_device_plugin_info

(

const BuiltInDeviceDescriptor &

descriptor

)

The PluginInfo the host uses to instantiate descriptor through the device factory.

Exposed so a caller can build the same descriptor the binding would, without reaching into the resolver.

calculate_lowerable_graph_latency_samples()

int pulp::host::calculate_lowerable_graph_latency_samples	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections,
		const std::function< int(NodeId)> &	custom_latency_for )

canonical_plugin_identity()

std::variant< CanonicalPluginIdentity, PluginIdentityError > pulp::host::canonical_plugin_identity

(

const PluginIdentityEvidence &

)

Encodes only type identity; preserves evidence without increasing its trust.

canonical_voice_identity()

VoiceIdentityResult pulp::host::canonical_voice_identity

(

const VoiceIdentityKey &

key

)

Encode and hash an authored identity using the G-4 v1 tagged, length-delimited wire form.

Strings are NFC UTF-8 and length-prefixed by big-endian uint32; integer fields are big-endian. Returns an invalid result without bytes or a digest when the key is not canonical.

cap_clap_plugin_count()

uint32_t pulp::host::cap_clap_plugin_count ( uint32_t count )

noexcept

capture_port_identity_undo()

PortIdentityUndo pulp::host::capture_port_identity_undo	(	std::span< const PortHandle >	before,
		std::span< const PortIdentityAlias >	aliases = {} )

choice_applies()

bool pulp::host::choice_applies ( const ForgeParamChoice & choice, std::string_view mode )

inlinenoexcept

classify()

ConnectionClass pulp::host::classify

(

const Connection &

c

)

commit_plugin_parameter_event_sequences()

void pulp::host::commit_plugin_parameter_event_sequences ( std::span< PluginBindingContext > contexts )

noexcept

connect_subgraph_ports()

GraphResult pulp::host::connect_subgraph_ports	(	SignalGraph &	graph,
		const SubgraphInstance &	source,
		std::string_view	source_port,
		const SubgraphInstance &	destination,
		std::string_view	destination_port )

connection_affects_latency()

bool pulp::host::connection_affects_latency

(

const Connection &

c

)

create_editor_container()

void * pulp::host::create_editor_container	(	void *	parent_window,
		uint32_t	width,
		uint32_t	height )

Create a container view sized (width, height), inserted into parent_window's content view.

Returns nullptr when parent_window is null or the platform has no native-window seam. The caller owns the result and must release it with destroy_editor_container().

create_processor_signal_graph_authority()

SignalGraphControlAuthority * pulp::host::create_processor_signal_graph_authority ( format::Processor & processor )

noexcept

Resolver used by the canonical standalone control host.

It returns the authority registered for this exact Processor instance, or nullptr when the product has not installed a binding or has released it.

create_processor_signal_graph_authority_lease()

ProcessorSignalGraphBinding::Lease pulp::host::create_processor_signal_graph_authority_lease ( format::Processor & processor )

noexcept

derive_mpe()

HostEventResult pulp::host::derive_mpe ( std::span< const HostEventRecord > events, std::uint64_t block_start, midi::MpeVoiceTracker & tracker, midi::MpeBuffer & out )

inlinenoexcept

Convert projected records to the existing MPE sidecar.

The tracker and sidecar are caller-owned and must be prepared with their realtime capacity before a callback uses this helper.

describe_forge_audit_finding()

std::string pulp::host::describe_forge_audit_finding

(

const ForgeAuditFinding &

finding

)

Human-readable one-line rendering, for a test failure or a CLI report.

destroy_editor_container()

void pulp::host::destroy_editor_container

(

void *

container

)

Remove the container from its superview and release it. No-op when null.

diff_port_identities()

PortIdentityDiff pulp::host::diff_port_identities	(	std::span< const PortHandle >	before,
		std::span< const PortHandle >	after,
		std::span< const PortIdentityAlias >	aliases = {} )

editor_container_adopt_view()

bool pulp::host::editor_container_adopt_view	(	void *	container,
		void *	native_view,
		uint32_t	width,
		uint32_t	height )

Insert an already-created native child view into container, sized to fill it and set to track the container's size.

This is for formats whose editor RETURNS a view (AU Cocoa UI) instead of consuming a parent — unlike CLAP / VST3, which the plug-in inserts itself into the container. Returns false if either argument is null or the platform has no native-window seam.

editor_container_scale()

double pulp::host::editor_container_scale

(

void *

parent_window

)

Backing scale factor of parent_window (2.0 on Retina), for the plugin's scale negotiation.

Returns 1.0 when unknown or unsupported.

evaluate_graph_timing_contract()

GraphTimingEvidence pulp::host::evaluate_graph_timing_contract ( const SignalGraph & graph, const GraphTimingDeclaration & declaration, const GraphTimingMeasurements & measurements )

noexcept

evaluate_live_swap_admission()

LiveSwapAdmission pulp::host::evaluate_live_swap_admission	(	const audio::AudioProcessLoadSnapshot &	graph,
		const std::vector< audio::AudioProcessLoadSnapshot > &	staged_nodes,
		float	headroom_threshold,
		std::uint64_t	min_callbacks )

event_device_latency_ceiling_samples()

int pulp::host::event_device_latency_ceiling_samples ( )

noexcept

The per-chain event-compensation ceiling, in samples.

A chain whose accumulated device latency exceeds it is refused rather than compensated. Exposed as a function so the value stays owned by the graph binding that enforces it and no caller can drift from it by re-declaring a constant.

find_builtin_device()

const BuiltInDeviceDescriptor * pulp::host::find_builtin_device ( std::string_view binding_key )

noexcept

The descriptor for binding_key, or nullptr when no built-in owns it.

find_param()

const ForgeParamDescriptor * pulp::host::find_param ( const ForgeNodeDescriptor & node, std::string_view key )

inlinenoexcept

Look up a parameter descriptor by its stable key.

Returns nullptr when absent, so a caller can decide whether that is a lookup miss or a contract violation.

find_scan_worker()

std::string pulp::host::find_scan_worker

(

std::string_view

explicit_path = {}

)

Locate the pulp-scan-worker binary for isolated scanning.

Order: explicit_path when non-empty, the PULP_SCAN_WORKER environment variable, then pulp-scan-worker beside the running executable or under bin/ or tools/scan-worker/ in that directory and up to four parents, which covers an installed SDK (bin/pulp next to bin/pulp-scan-worker), a build tree (tools/cli/pulp-cpp and tools/scan-worker/pulp-scan-worker), and test binaries under build/test/. The walk stops at an application bundle (.app) and at the first directory that holds a bin/, so it never reaches /Applications or another install prefix's siblings. A candidate that is group- or world-writable is refused with a warning, since anyone who can write it can run code in every scan. Returns an empty string when no candidate qualifies; an explicit or environment path is returned only when it exists and qualifies.

forge_audit_fault_name()

const char * pulp::host::forge_audit_fault_name

(

ForgeAuditFault

fault

)

forge_catalog_export_nodes()

std::vector< ForgeCatalogExportNode > pulp::host::forge_catalog_export_nodes

(

)

Build the semantic catalog projection used by both the CLI and the installed SDK snapshot.

forge_sample_region_v1()

const ForgeSampleRegionV1 * pulp::host::forge_sample_region_v1 ( std::string_view type_id )

inlinenoexcept

A legacy realization without an exact v1 route remains block-only.

generated_device_admission()

GeneratedDeviceAdmission pulp::host::generated_device_admission ( GeneratedDevicePlatform platform, GeneratedDeviceArtifact artifact, GeneratedDeviceOrigin origin )

nodiscardconstexprnoexcept

Returns the platform policy before any executable artifact is opened.

Frozen audio plus its recipe is the portable fallback on every platform.

instantiate_subgraph()

SubgraphExpansionResult pulp::host::instantiate_subgraph	(	SignalGraph &	graph,
		const SubgraphTemplate &	definition,
		std::string	instance_identity,
		std::uint32_t	instance_index = 0 )

is_sample_region_v1_descriptor()

bool pulp::host::is_sample_region_v1_descriptor ( const SampleKernelDescriptor & descriptor )

noexcept

load_baked() [1/2]

LowerResult pulp::host::load_baked	(	std::span< const std::uint8_t >	bytes,
		const BakedTrust &	trust,
		const std::vector< CustomNodeType > &	custom_types )

load_baked() [2/2]

template<typename Registry>
requires std::is_same_v<std::remove_cvref_t<Registry>, BakedTypeRegistry>

LowerResult pulp::host::load_baked	(	std::span< const std::uint8_t >	bytes,
		const BakedTrust &	trust,
		Registry &&	registry )

load_baked_plan()

BakedPlanLoadResult pulp::host::load_baked_plan	(	std::span< const std::uint8_t >	bytes,
		const BakedTrust &	trust,
		const std::vector< BakedTypeRegistration > &	registrations )

load_builtin_plugin()

std::unique_ptr< PluginSlot > pulp::host::load_builtin_plugin

(

const PluginInfo &

info

)

Loads a pathless Pulp-owned device. Unknown keys and non-empty paths fail closed.

load_clap_plugin_exact()

PluginLoadResult pulp::host::load_clap_plugin_exact

(

const PluginSelection &

selection

)

load_node_pack() [1/2]

NodePackLoadResult pulp::host::load_node_pack	(	const std::string &	manifest_dir,
		const NodePackManifest &	manifest,
		const NodePackTrust &	trust )

load_node_pack() [2/2]

NodePackLoadResult pulp::host::load_node_pack	(	const std::string &	manifest_dir,
		const NodePackManifest &	manifest,
		const NodePackTrust &	trust,
		const NodePackHostPolicy &	policy )

load_verified_node_pack()

NodePackLoadResult pulp::host::load_verified_node_pack	(	VerifiedNodePackBinary	binary,
		const NodePackManifest &	manifest,
		const NodePackTrust &	trust,
		const NodePackHostPolicy &	policy )

lowerability_of()

LowerabilityProof pulp::host::lowerability_of	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections,
		const std::function< const CustomNodeType *(std::string_view type_id, int version)> &	resolve_custom = {} )

make_bounded_delay_registration()

BoundedDelayRefusalReason pulp::host::make_bounded_delay_registration	(	const BoundedDelayDescriptor &	descriptor,
		BoundedDelayRegistration &	registration )

node_pack_signed_message()

std::vector< std::uint8_t > pulp::host::node_pack_signed_message

(

const NodePackManifest &

m

)

normalize_authored_identity_text()

bool pulp::host::normalize_authored_identity_text	(	std::string_view	input,
		std::string &	output )

Normalize one authored identity segment to NFC UTF-8 and reject malformed, NUL-containing, or control-character input.

This narrow value-only helper avoids pulling graph node types into identity consumers.

param_applies()

bool pulp::host::param_applies ( const ForgeParamDescriptor & param, std::string_view mode )

inlinenoexcept

True when param applies to the named realization mode.

parse_node_pack_manifest()

bool pulp::host::parse_node_pack_manifest	(	const std::string &	json,
		NodePackManifest &	out )

parse_plugin_identity_evidence()

std::optional< PluginIdentityEvidence > pulp::host::parse_plugin_identity_evidence

(

std::string_view

)

plugin_info_from_au_identity()

bool pulp::host::plugin_info_from_au_identity	(	std::string_view	identity,
		PluginInfo &	info )

port_identity_fingerprint()

std::uint64_t pulp::host::port_identity_fingerprint	(	std::span< const PortHandle >	ports,
		std::span< const PortIdentityAlias >	aliases = {} )

processor_restore_code_name()

const char * pulp::host::processor_restore_code_name ( ProcessorRestoreCode code )

noexcept

Stable names for machine-readable diagnostics; messages are supplementary.

project_host_event_block()

HostEventResult pulp::host::project_host_event_block ( std::span< const HostEventRecord > records, std::uint64_t block_start, std::size_t frames, midi::MidiBuffer & midi_out, midi::MpeVoiceTracker * tracker = nullptr, midi::MpeBuffer * mpe_out = nullptr )

inlinenoexcept

Project an already-sorted absolute host-event block into the fixed MIDI, UMP, and optional MPE sidecars consumed by SignalGraph's existing ingress mailbox.

The caller owns and prepares the destination buffers before the realtime boundary. Every record is checked before any destination is mutated, so an out-of-window record or insufficient sidecar capacity leaves all three destinations unchanged.

This is deliberately an adapter, not a scheduler: block_start and frames define the one block being delivered, and records outside that window are refused rather than retimed. The resulting buffers can be passed directly to SignalGraph::inject_midi(node, midi, mpe); that API preserves the same payload on both the routed and legacy execution paths.

prove_sample_region()

SampleRegionProof pulp::host::prove_sample_region

(

const SampleRegionCandidate &

candidate

)

prove_sample_region_parser_shape()

SampleRegionParserProof pulp::host::prove_sample_region_parser_shape

(

const SampleRegionParserShape &

shape

)

prove_sample_regions()

SampleRegionGraphProof pulp::host::prove_sample_regions

(

const std::vector< SampleRegionCandidate > &

candidates

)

register_bounded_delay()

BoundedDelayRefusalReason pulp::host::register_bounded_delay	(	SignalGraph &	graph,
		const BoundedDelayDescriptor &	descriptor )

register_builtin_sample_region_types() [1/2]

bool pulp::host::register_builtin_sample_region_types

(

SignalGraph &

graph

)

register_builtin_sample_region_types() [2/2]

bool pulp::host::register_builtin_sample_region_types

(

SignalGraph::PreparedTopologyEdit &

edit

)

render_timeline_offline()

TimelineOfflineRenderResult pulp::host::render_timeline_offline	(	SignalGraph &	graph,
		TimelineGraphPlaybackBinding &	binding,
		const playback::PlaybackProgram &	program,
		std::span< const TimelineTrackGraphRoute >	routes,
		const TimelineOfflineRenderConfig &	config,
		const TimelineOfflineRenderOptions &	options )

Renders [start_tick, end_tick) of program through graph, plus a fixed tail, and returns deterministic Float32 audio.

graph must be freshly built or quiesced: the renderer prepares the binding itself and drives its own transport, so a graph already bound to a live transport would be double-driven.

A region whose start is not block-aligned is rendered by pre-rolling from tick origin with output discarded, so stateful nodes (delays, PDC) enter the region with exactly the history a full bounce would have given them. That is the difference between "renders a region" and "renders a region correctly", and it is why the region slice equals the corresponding slice of a full bounce rather than merely resembling it.

reset_plugin_parameter_event_sequences()

void pulp::host::reset_plugin_parameter_event_sequences ( std::span< PluginBindingContext > contexts )

noexcept

resize_editor_container()

void pulp::host::resize_editor_container	(	void *	container,
		uint32_t	width,
		uint32_t	height )

Resize an existing container. No-op when container is null.

restore_subgraph_state()

GraphResult pulp::host::restore_subgraph_state	(	SignalGraph &	graph,
		SubgraphInstance &	instance,
		const SubgraphState &	state )

sample_kernel_storage_is_disjoint()

bool pulp::host::sample_kernel_storage_is_disjoint ( const SampleKernelDescriptor & descriptor, const void * state, const PreparedSampleKernelConfig & config, const SampleFrameContext & frame, const float * inputs, float * outputs )

noexcept

sample_region_config_matches()

bool pulp::host::sample_region_config_matches ( const SampleKernelConfig & config, const SampleKernelDescriptor & descriptor )

noexcept

scan_clap_bundle_descriptors()

std::vector< PluginInfo > pulp::host::scan_clap_bundle_descriptors

(

const std::string &

path

)

serialize_forge_catalog_json()

std::string pulp::host::serialize_forge_catalog_json

(

const std::vector< ForgeCatalogExportNode > &

nodes

)

serialize_plugin_identity_evidence()

std::string pulp::host::serialize_plugin_identity_evidence

(

const PluginIdentityEvidence &

)

Unsigned serialized captures always import as declared, even if originally loaded.

signal_graph_executor_eligible()

bool pulp::host::signal_graph_executor_eligible

(

const SignalGraph &

graph

)

signal_graph_topology_executor_eligible()

bool pulp::host::signal_graph_topology_executor_eligible	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections )

undo_port_identity()

std::vector< PortHandle > pulp::host::undo_port_identity

(

const PortIdentityUndo &

undo

)

unload_node_pack()

void pulp::host::unload_node_pack

(

void *

handle

)

validate_plugin_type_identity()

std::optional< PluginIdentityError > pulp::host::validate_plugin_type_identity

(

const PluginTypeIdentity &

)

Pure validation: nonempty, bounded UTF-8 without NUL or Unicode controls.

validate_port_identities()

PortIdentityReport pulp::host::validate_port_identities	(	std::span< const PortHandle >	ports,
		std::span< const PortIdentityAlias >	aliases = {} )

validate_signal_graph_executor_topology()

ExecutorTopologyValidation pulp::host::validate_signal_graph_executor_topology	(	std::span< const GraphNode >	nodes,
		std::span< const Connection >	connections,
		graph::GraphRuntimeLimits	limits = {} )

verify_and_extract_plan()

std::optional< BakedPlan > pulp::host::verify_and_extract_plan	(	std::span< const std::uint8_t >	bytes,
		const BakedTrust &	trust )

verify_node_pack_binary()

NodePackVerifyResult pulp::host::verify_node_pack_binary	(	const std::string &	manifest_dir,
		const NodePackManifest &	manifest )

write_baked_signed()

std::vector< std::uint8_t > pulp::host::write_baked_signed	(	const BakedPlan &	plan,
		std::span< const std::uint8_t >	private_key_64 )

Variable Documentation

kAdmittedDeviceChainLength

std::size_t pulp::host::kAdmittedDeviceChainLength = 2

inlineconstexpr

The longest device chain the host binding lowers today.

Any number of event-to-event devices would be sound, but each one needs its own prepared node and event edge, and two is what the graph, the shift accumulator, and the reconciler are proven against. A longer chain is refused at admission rather than truncated, and the bound is public so a caller can predict that refusal instead of discovering it on a round trip.

kBakedManifestMaxBytes

std::size_t pulp::host::kBakedManifestMaxBytes = 4096

inlineconstexpr

kBakedManifestSchemaVersion

int pulp::host::kBakedManifestSchemaVersion = 1

inlineconstexpr

kBakedMaxBlock

int pulp::host::kBakedMaxBlock = 16384

inlineconstexpr

kBakedMaxConnections

std::size_t pulp::host::kBakedMaxConnections = 2048

inlineconstexpr

kBakedMaxCustomState

std::size_t pulp::host::kBakedMaxCustomState = 65536

inlineconstexpr

kBakedMaxCustomTypeId

std::size_t pulp::host::kBakedMaxCustomTypeId = 256

inlineconstexpr

kBakedMaxNodes

std::size_t pulp::host::kBakedMaxNodes = 512

inlineconstexpr

kBakedMaxPlanBytes

std::size_t pulp::host::kBakedMaxPlanBytes = 4u * 1024u * 1024u

inlineconstexpr

kBakedMaxPortsPerNode

int pulp::host::kBakedMaxPortsPerNode = 64

inlineconstexpr

kBakedMaxRegionBoundaries

std::size_t pulp::host::kBakedMaxRegionBoundaries = 8

inlineconstexpr

kBakedMaxRegionMembers

std::size_t pulp::host::kBakedMaxRegionMembers = 64

inlineconstexpr

kBakedMaxRegionParameters

std::size_t pulp::host::kBakedMaxRegionParameters = 16

inlineconstexpr

kBakedMaxRegions

std::size_t pulp::host::kBakedMaxRegions = 16

inlineconstexpr

kBakedMaxRegionString

std::size_t pulp::host::kBakedMaxRegionString = 1024

inlineconstexpr

kBakedMaxSupportedFormatVersion

int pulp::host::kBakedMaxSupportedFormatVersion = 2

inlineconstexpr

kBakedMaxTotalPorts

std::size_t pulp::host::kBakedMaxTotalPorts = 4096

inlineconstexpr

kBakedPlanFormatVersion

int pulp::host::kBakedPlanFormatVersion = kBakedMaxSupportedFormatVersion

inlineconstexpr

kBakedPlanV1FormatVersion

int pulp::host::kBakedPlanV1FormatVersion = 1

inlineconstexpr

kBasicInstrumentBindingKey

std::string_view pulp::host::kBasicInstrumentBindingKey = "pulp.instrument.basic"

inlineconstexpr

Durable Timeline binding key for Pulp's pathless basic instrument.

kEventHumaniserBindingKey

std::string_view pulp::host::kEventHumaniserBindingKey = "pulp.device.event.humanise"

inlineconstexpr

Durable Timeline binding key for Pulp's pathless look-ahead note humaniser.

kEventHumaniserTimingDepthParamId

std::uint32_t pulp::host::kEventHumaniserTimingDepthParamId = 1

inlineconstexpr

Stable parameter IDs exposed by the built-in humaniser.

Timing depth is a normalized share of the fixed look-ahead window; velocity depth is the maximum MIDI-velocity displacement. Neither changes reported latency.

kEventHumaniserVelocityDepthParamId

std::uint32_t pulp::host::kEventHumaniserVelocityDepthParamId = 2

inlineconstexpr

kEventHumaniserWindowSamples

int pulp::host::kEventHumaniserWindowSamples = 512

inlineconstexpr

The humaniser's look-ahead window, in samples, and therefore the latency it reports.

A note can only be displaced by a device that received it before its nominal time, so the window is what buys the device the right to place a note anywhere in [nominal - window, nominal] once the host has shifted the scheduling window by the same amount. Timing depth changes the jitter span inside this fixed window; it never changes the reported latency because the host resolves and caches the compensation shift before playback.

kForgeSampleRegionV1

ForgeSampleRegionV1 pulp::host::kForgeSampleRegionV1[]

inlineconstexpr

Initial value:

= {
    {"input_boundary", "pulp.core.sample-region.input", "Sample Region Input", 1, 1, 1, 1, 0, 1,
     "BoundaryIndex", "region_builder_only"},
    {"output_boundary", "pulp.core.sample-region.output", "Sample Region Output", 1, 1, 1, 1, 0, 1,
     "BoundaryIndex", "region_builder_only"},
    {"constant", "pulp.core.sample-region.constant", "Constant", 1, 1, 0, 1, 0, 1, "FiniteConstant",
     "normal_node"},
    {"parameter", "pulp.core.sample-region.parameter", "Parameter", 1, 1, 0, 1, 0, 1,
     "PromotedParameterId", "normal_node"},
    {"add", "pulp.core.sample-region.add", "Add", 1, 1, 2, 1, 0, 1, "None", "normal_node"},
    {"multiply", "pulp.core.sample-region.multiply", "Multiply", 1, 1, 2, 1, 0, 1, "None",
     "normal_node"},
    {"unit_delay", "pulp.core.unit-delay", "Unit Delay", 1, 1, 1, 1, 4, 4, "None", "normal_node"},
}