Namespaces
namespace	detail
namespace	methods

Classes
struct	InspectorAgentContext
	Host-owned snapshot returned by Inspector.getAgentContext. More...
class	InspectorAgentContextSource
	Composition seam for host state that does not belong in protocol dispatch. More...
struct	AgentRequest
	One queued request from the human, with the context the agent needs to act without guessing which design/screen/state it refers to. More...
struct	AudioConfig
	Audio configuration snapshot. More...
struct	MidiLogEntry
	A single MIDI event for logging. More...
struct	BufferUnderrun
	Buffer underrun event. More...
struct	ChannelLevels
	Per-channel audio levels. More...
struct	AudioRuntimeTelemetry
	Cheap runtime telemetry bridge for agent/UI polling. More...
class	AudioInspector
	Monitors audio thread performance and state for the inspector. More...
struct	InspectorAuditEntry
	Metadata-only record for a mutating inspector request. More...
class	InspectorAuditLog
struct	ControlSecurityAuditEntry
	Metadata-only security event. More...
class	ControlSecurityAuditLog
struct	InspectorAuthChallenge
class	InspectorAuthVerifier
	One-shot verifier for a server-issued nonce. More...
struct	InspectorMethodDescriptor
struct	InspectorCapabilityDescriptor
struct	InspectorCapture
class	InspectorCaptureSource
	Host-owned image source. More...
struct	InspectorClientTarget
	Exact selector for one canonical control registration generation. More...
struct	InspectorClientResult
	Typed outcome for a one-shot canonical control request. More...
class	ConsoleCapture
	Captures JS console output (console.log/warn/error) for inspector display. More...
struct	ControlAdmissionRequest
struct	ControlAdmissionPlan
	Immutable authority snapshot minted by ControlBroker after all seven permission terms pass. More...
struct	ControlAdmissionResult
struct	ControlAdmissionPolicy
	Trusted, bounded, non-blocking broker-side evaluators for the three dynamic permission terms not owned by identity, manifest, or grant state. More...
struct	ControlArtifactLineage
struct	ControlArtifactProperties
struct	ControlArtifactMetadata
struct	ControlArtifactStoreConfig
struct	ControlArtifactDeletionRecord
	Persisted deletion evidence intentionally excludes client-provided content, paths, consent text, and plugin metadata. More...
struct	ControlArtifactCollectionResult
struct	ControlArtifactStoreResult
struct	ControlArtifactReadResult
class	ControlArtifactStore
	Broker-owned content-addressed artifact persistence. More...
struct	ControlBrokerConfig
struct	ControlBrokerLifecycleResult
class	ControlBroker
	Dormant composition root for the local capability-control broker. More...
struct	ControlEndpointIdentity
	Filesystem identity captured for an owner-private local socket endpoint. More...
struct	ControlTransportDispatchResult
class	ControlClientTransport
	One authenticated, connection-bound capability-control session. More...
struct	ControlDispatchResult
class	ControlClient
	Typed capability-control client over one connection-bound transport. More...
struct	ControlClientConnectionConfig
class	ControlClientConnection
	Concrete OS-local transport for one authenticated control session. More...
struct	ControlClientConnectionPrincipal
struct	ControlHostConnectionPrincipal
struct	ControlConnectionAdmission
struct	ControlConnectionAdmissionTicket
struct	ControlConnectionAdmissionResult
struct	ControlConnectionAdmissionStoreConfig
class	ControlConnectionAdmissionStore
	Broker-owned, process-local admission registry for authenticated carriers. More...
struct	ControlConsentPrompt
struct	ControlBrokerConsentAuthorityConfig
class	ControlBrokerConsentAuthority
	Process-local production consent authority. More...
struct	ControlEndpointEnrollmentContext
	Explicit injection seam for endpoint-owned enrollment. More...
struct	ControlTrustedHostManagementLaunchResult
struct	ControlTrustedHostManagement
struct	ControlEndpointConfig
class	ControlEndpoint
	OS-local carrier for one ControlService composition root. More...
struct	ControlExecutionOutcome
struct	ControlArtifactPublication
struct	ControlExecutionContext
class	ControlOperationExecutorSlot
	One-time late binding for a host operation executor. More...
class	ControlGpuHealthProvider
	UI-thread producer for the immutable snapshot consumed by dev.pulp.gpu/health.read@1. More...
struct	ControlGpuHealthReadSource
	Exact-instance source for a bounded GPU startup-health snapshot. More...
class	ControlGpuHealthViewAdapter
	Pulp-owned UI-thread bridge from a concrete Standalone/plugin/constrained host to ControlGpuHealthProvider. More...
struct	ControlGrantId
struct	ControlConsentDecision
struct	ControlGrantRequest
struct	ControlGrantConsentRequest
	Consent input assembled only after the broker has authenticated the client and resolved an exact live registration and selector. More...
struct	ControlGrant
struct	ControlGrantResult
struct	ControlOperationAuthorization
struct	ControlGrantStoreConfig
class	ControlGrantStore
	Stores only the client_granted term of the permission equation. More...
struct	ControlBrokerHealth
struct	ControlHealthProbeConfig
struct	ControlBrokerHealthProbeResult
struct	ControlHostBootstrapDiagnostics
class	ControlHostBootstrapRecord
	One-shot inherited authority material. More...
class	ControlHostBootstrapBytes
struct	ControlHostConnectionConfig
class	ControlHostConnection
	Authenticated host-role carrier over the canonical ControlEnvelope stream. More...
struct	ControlUiObservationRequest
struct	ControlUiObservation
struct	ControlDiagnosticItem
struct	ControlLogEntry
struct	ControlLogPage
struct	ControlTestNoteInput
struct	ControlTestTransportInput
struct	ControlAuthoringChanges
struct	ControlAuthoringApplyResult
struct	ControlHostDevelopmentBinding
struct	ControlHostDevelopmentExecutorConfig
class	ControlHostDevelopmentExecutor
	Canonical host-main composition for bounded development outcomes that do not belong to state, capture, Motion, telemetry, or runtime evaluation. More...
struct	ControlHostEnrollmentTicket
struct	ControlHostEnrollmentResult
class	ControlHostEnrollmentPlan
	Move-only broker plan binding one consumed immutable launch snapshot to the exact preobserved process the broker launched. More...
struct	ControlHostEnrollmentStoreConfig
class	ControlHostEnrollmentStore
	Bounded, process-local enrollment registry. More...
struct	ControlHostObservabilityBinding
struct	ControlHostObservabilityBundleConfig
class	ControlHostObservabilityBundle
	Registration-scoped canonical trace and telemetry executor bundle. More...
struct	ControlHostPreflightDiagnostics
class	ControlHostRouter
	Dormant broker-to-host route selector. More...
struct	ControlUiExactTarget
	A node name is never authority by itself. More...
struct	ControlUiAuthorityOwner
	Broker-owned opaque authority owner for UI state retained between receipts. More...
struct	ControlUiProjectedAuthority
	Live broker authority projected to the exact enrolled host. More...
struct	ControlUiPointerInput
struct	ControlUiKeyboardInput
struct	ControlUiFocusInput
struct	ControlUiTextInput
class	ControlHostUiTargetAdapter
	Pulp-owned composition seam for an ordinary Standalone view tree. More...
struct	ControlHostUiBinding
struct	ControlHostUiExecutorConfig
class	ControlHostUiExecutor
	Canonical exact-instance adapter for screenshot capture, bounded UI input, and explicitly unsafe research evaluation. More...
struct	ControlBrokerId
struct	ControlClientId
struct	ControlRegistrationId
struct	ControlPeerEvidence
	Evidence observed by the local IPC carrier. More...
class	VerifiedControlPeerIdentity
	Copyable proof minted only by the broker's trusted OS peer verifier. More...
class	ControlPeerVerifier
	Converts carrier-observed process evidence into an unforgeable-by-payload identity. More...
class	ControlBootstrapSecret
	Move-only bootstrap material. Destruction wipes the secret bytes. More...
struct	ControlBootstrapTicket
struct	ControlBootstrapResult
struct	ControlClientIdentity
struct	ControlClientResult
struct	ControlRegistrationRequest
struct	ControlRegistration
struct	ControlRegistrationResult
struct	ControlIdentityRegistryConfig
class	ControlIdentityRegistry
	Broker-owned identity state. More...
struct	InspectorControlSession
	Authority material returned by an enrollment-aware client integration. More...
class	InspectorControlSessionOpener
	Injected enrollment/session boundary for canonical Inspector operations. More...
struct	ControlInstalledHostUiTargets
struct	ControlInstalledHostUiConfig
struct	ControlInstalledHostDevelopmentConfig
struct	ControlInstalledHostConfig
class	ControlInstalledHost
	Production ownership seam for one broker-launched installed T1 host. More...
class	ControlMainThreadExecutor
	Adapts typed control execution onto the completion-carrying Inspector main thread RPC without creating another queue or transport. More...
struct	ControlManifest
struct	ControlManifestDiagnostics
struct	ControlManifestValidation
struct	ControlArtifactExpectation
struct	ControlArtifactValidation
struct	ControlArtifactResultBinding
	A frozen Product A operation contract. More...
struct	ControlReceiptResultBinding
	Binds a typed success-result field to the broker-minted durable receipt. More...
struct	ControlOperationDescriptor
struct	ControlPermissionInputs
	Inputs to the canonical permission equation. More...
struct	ControlPermissionDecision
struct	ControlMotionTarget
	Exact T1 host state resolved after canonical admission. More...
struct	ControlMotionExecutorConfig
class	ControlMotionExecutor
	Executes dev.pulp.trace/control@1 without invoking the deleted Motion RPC transport. More...
struct	ControlOfflineRenderSource
	Owned, transport-independent input resolved by a trusted T0 launcher from the request's opaque input artifact ID. More...
struct	ControlReceiptId
struct	ControlAuthorityBinding
	Canonical immutable snapshot of the authority under which an operation was admitted. More...
struct	ControlOperationBinding
	The complete idempotency scope for one admitted operation. More...
struct	ControlOperationResult
struct	ControlOperationReceipt
struct	ControlOperationStoreResult
struct	ControlOperationStoreConfig
class	ControlOperationStore
	Durable broker operation receipt and idempotency ledger. More...
struct	ControlPeerExpectation
	Exact broker-owned peer expectation. More...
struct	ControlProtocolRange
struct	ControlNegotiationOffer
struct	ControlNegotiationResult
struct	ControlRequestEnvelope
struct	ControlCancelEnvelope
struct	ControlProgressEnvelope
	A bounded progress observation for one admitted operation. More...
struct	ControlSessionOpenEnvelope
struct	ControlSessionOpenResult
struct	ControlManagementEnvelope
	Finite broker-management family used by installed control adapters. More...
struct	ControlManagementResult
struct	ControlHostOpenEnvelope
struct	ControlHostOpenResult
struct	ControlHostReadyEnvelope
struct	ControlHostReadyResult
struct	ControlHostHeartbeatEnvelope
struct	ControlHostHeartbeatResult
struct	ControlHostPreflightChallengeEnvelope
struct	ControlHostPreflightResponseEnvelope
struct	ControlHostPreflightBootstrapEnvelope
struct	ControlHostPreflightReceiptEnvelope
struct	ControlHostExecuteEnvelope
	Broker-to-host execution request. More...
struct	ControlHostAuthorityEndEnvelope
struct	ControlHostProgressEnvelope
struct	ControlHostCancelEnvelope
struct	ControlArtifactReadEnvelope
struct	ControlArtifactWireMetadata
	Flattened, bounded wire representation of artifact metadata. More...
struct	ControlArtifactReadResponseEnvelope
struct	ControlHealthEnvelope
struct	ControlHealthResult
struct	ControlErrorEnvelope
struct	ControlHostArtifactPublication
	Host-authored execution outcome. More...
struct	ControlHostCompleteEnvelope
struct	ControlArtifactHandle
struct	ControlReceiptEnvelope
struct	ControlLegacyInspectorError
	Lossless compatibility detail for a failed operation declared with the legacy-inspector-json-v1 adapter encoding. More...
struct	ControlEnvelope
struct	ControlProtocolDiagnostics
struct	ControlJsonSchemaDiagnostics
struct	ControlSampleRegionGeneration
	The host shares this authority with every topology publication for one graph. More...
class	ControlSampleRegionTarget
struct	ControlSequencerStateTarget
	Exact live sequencer channel resolved only after broker admission. More...
struct	ControlSequencerTransportTarget
	The exact live transport an admitted registration may observe and edit. More...
struct	ControlServiceResult
struct	ControlServiceConfig
class	ControlService
	Dormant typed dispatcher over the broker composition root. More...
struct	ControlStandaloneUiAdapterConfig
class	ControlStandaloneUiAdapter
	Ordinary Standalone implementation of the Pulp-owned UI adapter seam. More...
struct	ControlStateReadSource
	A legal-thread view of one exact runtime's StateStore. More...
struct	ControlStateWriteTarget
	Exact T1/T2a mutable state resolved only after broker admission. More...
struct	ControlTelemetryAuthority
struct	ControlTelemetrySubscriptionRequest
struct	ControlTelemetryChannelSample
struct	ControlTelemetryFrame
struct	ControlTelemetryTapConfig
class	ControlTelemetryTap
	Canonical transport-free, bounded fan-out telemetry tap. More...
struct	ControlTimelineDocumentSessionRequest
	One decoded document-session request, already validated against the operation's input schema and the broker's writer-profile policy. More...
struct	ControlTimelineDocumentSessionOutcome
	One typed outcome from the bound timeline::DocumentSession. More...
struct	ControlTimelineDocumentSessionSource
	Exact-instance source for one live mutable Timeline document session. More...
struct	ControlTraceSessionExecutorConfig
class	ControlTraceSessionExecutor
	Executes the canonical trace-session operation through the existing process-global tracing owner on the registered host main thread. More...
struct	ControlTrustedHostLaunchIntent
struct	ControlTrustedHostInventoryConfig
struct	ControlTrustedHostInventoryTicket
struct	ControlTrustedHostInventoryPrepareResult
struct	ControlTrustedHostStaticExpectation
	Exact static-code expectation derived from the staged destination. More...
struct	ControlTrustedHostRuntimeDependencyPolicy
struct	ControlTrustedHostPreparationPolicy
class	ControlTrustedHostSnapshot
	Immutable broker-owned launch material. More...
class	ControlTrustedHostInventory
	Process-local snapshot store intended to be owned by the broker composition root. More...
struct	ControlTrustedHostLauncherConfig
struct	ControlTrustedHostLaunchResult
class	ControlTrustedHostLauncher
	Broker composition seam for one inventory-approved raw host executable. More...
class	DomainHandler
	Handles inspector protocol requests by delegating to the appropriate inspector component. More...
struct	InspectorConfig
	Inspector runtime configuration. More...
struct	EffectiveEditorUrl
	Compute the effective template and its source given the supplied config. More...
struct	InspectorRequestContext
	Authenticated transport identity attached to a domain request. More...
class	InspectorOverlay
struct	BadgePlacement
	Computed top-left placement for a selection badge (the type W×H hover tooltip and the grid-refuse "can't move" badge). More...
class	CollapsableSection
	A disclosure-triangle section: click header to expand/collapse content. More...
class	ConsoleEntryView
	Displays a single console log entry with colored level badge and timestamp. More...
class	InspectorWindow
	Main tabbed inspector panel with four tabs: Elements \| Console \| Performance \| State. More...
class	InspectorMainThreadRpc
	Bounded response-after-apply handoff from an inspector transport thread to the registered host main thread. More...
struct	MotionGeometryMetric
struct	MotionScrollMetric
struct	MotionTraceSpec
struct	MotionTraceAttachResult
class	MotionInspector
class	MotionScrubber
struct	InspectorMessage
	A single inspector protocol message (request, response, or event). More...
struct	RuntimeEvaluatorCapabilities
struct	RuntimeEvaluationResult
class	RuntimeEvaluator
	Host-injected arbitrary-execution boundary. More...
struct	InspectorPolicyConfig
class	InspectorAccessPolicy
	Resolves named profiles and exact custom grants against capabilities that the host actually attached. More...
struct	InspectorControllerScopeEnd
class	InspectorControllerLease
	One-controller lease for mutating inspector operations. More...
struct	InspectorSessionInfo
class	InspectorSession
	Capability-enforcing dispatch facade. More...
struct	InspectorSkpCapture
class	SkpCaptureSource
	Host-owned serialized-frame source. More...
struct	SourceJumpResult
	Outcome of a source-jump resolution. More...
class	StateInspector
	Monitors StateStore parameters for the inspector. More...
struct	MidiTestInput
struct	StandaloneTransportTestInput
struct	TestInputApplyResult
class	InspectorTestInputSource
class	TestInputDomain
class	TraceOwnerLease
struct	TracePublicationOwner
class	TraceInspector
	Handles Trace.* protocol requests by driving pulp::runtime::Tracing. More...
class	TweakStore
	In-memory record of inspector direct-manipulation edits ("tweaks"), keyed by stable_anchor_id + dotted property path (e.g. More...
class	ValueChannelTelemetryBroker
	Transport-independent reader and bounded fan-out owner for value-channel telemetry. More...

Typedefs
using	ControlClientNegotiationResult = ControlDispatchResult<ControlNegotiationResult>
using	ControlClientReceiptResult = ControlDispatchResult<ControlReceiptEnvelope>
using	ControlConnectionPrincipal
using	ControlAdmissionConsumer
using	ControlProgressReporter
using	ControlExecutionGuard = std::function<ControlExecutionCheckpoint()>
using	ControlDeferredCompletion = std::function<void(ControlExecutionOutcome)>
using	ControlArtifactPublisher
using	ControlOperationExecutor
	Trusted in-process adapter contract.
using	ControlGpuHealthReadSourceResolver
using	ControlHostBootstrapHandle = int
using	ControlHostBootstrapProvider
	Mints one bootstrap only after the inherited channel has proven the exact live child.
using	ControlUiAuthorityResolver
using	ControlUiInput
using	ControlRuntimeEvalRedactor
using	ControlMotionTargetResolver
using	ControlOfflineRenderSourceResolver
using	ControlOfflineRenderClock
using	ControlEnvelopePayload
using	ControlSampleRegionTargetResolver
using	ControlSequencerStateTargetResolver
using	ControlSequencerTransportTargetResolver
using	ControlSignalGraphAuthorityResolver
using	ControlStateReadSourceResolver
using	ControlStateWriteTargetResolver
using	ControlTimelineDocumentSessionSourceResolver
using	InspectorEventSink = std::function<void(const InspectorMessage&)>
using	InspectorTargetedEventSink
using	InspectorEventRetirementSink
using	ScriptedUiSessionVisitor
	Construct a reload-safe evaluator that borrows the current scripted realm only for each bounded evaluator call.

Enumerations
enum class	InspectorAuditOutcome : std::uint8_t { Denied , Applied , Rejected }
enum class	ControlSecurityOutcome : std::uint8_t { Accepted , Denied , Revoked , Expired }
enum class	InspectorCapability : std::uint8_t { SessionDescribe , SessionControl , StateRead , GpuHealthRead , RenderOffline , UiRead , DiagnosticsRead , LogsRead , CaptureImage , UiInput , TraceControl , TraceSessionControl , StateWrite , TestInput , AuthoringTweaks , TelemetryStream , RuntimeReload , RuntimeEval , ArtifactRead , SequencerStateRead , SequencerStateEdit , SequencerTransportRead , SequencerTransportWrite , TimelineDocumentSession , GraphSampleRegionRead , GraphSampleRegionEdit , ModulationRouteEdit , Unavailable }
enum class	InspectorMethodKind : std::uint8_t { Request , Event }
enum class	InspectorCapabilityRisk : std::uint8_t { Observe , Sensitive , StreamingSensitive , ResourceConsuming , Control , HighRisk , Critical , Unavailable }
enum class	InspectorProfile : std::uint8_t { Off , Observe , Develop , Custom }
enum class	InspectorSideEffect : std::uint8_t { None , Session , State , Capture , Trace , TestInput , Authoring , Telemetry , Evaluation , Render , Input , Reload , ArtifactRead }
enum class	InspectorExecutor : std::uint8_t { Protocol , HostMain , Background , RuntimeEvaluator , OfflineJob }
enum class	InspectorEvidence : std::uint8_t { Response , Receipt , Artifact , Stream }
enum class	ControlAdmissionStatus : std::uint8_t { Admitted , InvalidRequest , UnknownOperation , IdentityMismatch , ArtifactLineageRequired , PermissionDenied , DurableStoreUnavailable , IdempotencyConflict , RequestIdConflict , ReplayWindowExpired , ResourceExhausted , DeadlineExceeded , CancelledBeforeDispatch }
enum class	ControlExecutionCheckpoint : std::uint8_t { Continue , Cancelled , DeadlineExceeded , AuthorityRevoked }
enum class	ControlArtifactSensitivity : std::uint8_t { Public , Internal , Sensitive , Restricted }
enum class	ControlArtifactDeletionState : std::uint8_t { Active , Deleted }
enum class	ControlArtifactRedactionState : std::uint8_t { Original , Redacted }
enum class	ControlEvidenceKind : std::uint8_t { Screenshot , OfflineRender , StateSnapshot , PerfettoTrace }
enum class	ControlArtifactStatus : std::uint8_t { Stored , Read , InvalidRequest , Unauthorized , NotFound , Corrupt , ResourceExhausted , IoError }
enum class	ControlArtifactDeletionReason : std::uint8_t { Expired , QuotaCollection , ExplicitDeletion , CrashCleanup }
enum class	ControlConnectionAdmissionStatus : std::uint8_t { Issued , InvalidRequest , ResourceExhausted , EntropyUnavailable }
enum class	ControlConsentPromptResult : std::uint8_t { Approved , Denied , TimedOut , Unavailable }
enum class	ControlConsentAuthority : std::uint8_t { None , TrustedPulpCli , TrustedHostUi , BrokerUserPrompt , ExistingUserPolicy , PluginUi , AgentClient }
enum class	ControlGrantStatus : std::uint8_t { Granted , InvalidRequest , BrokerMismatch , ClientUnavailable , RegistrationUnavailable , ConsentRequired , ConsentReplay , CapabilityUnavailable , ResourceExhausted , NotFound , Expired , Revoked }
enum class	ControlGrantSelectorKind : std::uint8_t { Profile , Operation }
enum class	ControlOperationAuthorizationKind : std::uint8_t { Reusable , ProvisionalOneShot , CommittedOneShot }
enum class	ControlBrokerHealthProbeStatus : std::uint8_t { Unavailable , ReachableUnverified , HealthyVerified , Incompatible , Malformed }
enum class	ControlHostBootstrapStatus : std::uint8_t { Accepted , Absent , Truncated , Oversize , InvalidRecord , UnsupportedVersion , Expired , ReadFailed }
enum class	ControlDiagnosticSeverity : std::uint8_t { Info , Warning , Error }
enum class	ControlHostEnrollmentStatus : std::uint8_t { Created , InvalidRequest , ResourceExhausted , EntropyUnavailable }
enum class	ControlHostPreflightStatus : std::uint8_t { Accepted , Unsupported , InvalidChannel , EntropyUnavailable , Timeout , MalformedMessage , DirectionMismatch , NonceMismatch , PeerUnavailable , ProcessMismatch , AuthorityRejected , SendFailed , BootstrapInvalid }
	Private transport preflight for an already-spawned host. More...
enum class	ControlUiApplyStatus : std::uint8_t { Applied , TargetUnavailable , StaleGeneration , InvalidEvent }
enum class	ControlPeerRole : std::uint8_t { Client , OfflineHost , StandaloneHost , TrustedHostBridge }
enum class	ControlHostTier : std::uint8_t { OfflineJob , Standalone , SharedPluginHost }
enum class	ControlIdentityStatus : std::uint8_t { Accepted , InvalidRequest , PeerRoleMismatch , HostUnavailable , AttestationUnavailable , IdentityMismatch , NotFound , Expired , Replay , ResourceExhausted , EntropyUnavailable }
enum class	ControlDurableClientLifetime : std::uint8_t { Broker , Process }
enum class	ControlProcessLiveness : std::uint8_t { Unknown , Alive , Dead }
enum class	ControlBuildProfile : std::uint8_t { ProductionStripped , DeveloperLocal , TestDeterministic , SupportDiagnostics , ResearchUnsafe }
enum class	ControlManifestError : std::uint8_t { None , Parse , RootType , UnknownField , MissingOrInvalidField , UnsupportedSchema , VersionDowngrade , VersionTooNew , UnknownProfile , PermissionTermsMismatch , CapabilityLimit , UnknownCapability , InvalidCapabilitySet , MissingCapabilityDependency , ProfileViolation , InvalidProfile , InvalidIdentity , RegistryMismatch , EndpointMismatch , UnsafeAcknowledgementMismatch }
enum class	ControlDenialReason : std::uint8_t { UnknownCapability , NotImplemented , NotBuilt , HostUnavailable , NotActivated , PolicyIneligible , ClientNotGranted , SessionNotLive , ProfileForbidden , UnsupportedExecutor , PublicationMismatch }
enum class	ControlOperationStoreStatus : std::uint8_t { Opened , Admitted , Replay , ReplayWindowExpired , Transitioned , CancellationRequested , IdempotencyConflict , RequestIdConflict , InvalidRequest , InvalidTransition , NotFound , ResourceExhausted , StoreUnavailable , MalformedStore , PersistenceError }
enum class	ControlNegotiationStatus : std::uint8_t { Accepted , InvalidOffer , NoCommonVersion , DowngradeRejected , UnsupportedMandatoryFeature }
enum class	ControlReceiptState : std::uint8_t { Admitted , Running , Completed , Failed , Cancelled , CompletedAfterRevocation , UnknownNeedsRefresh }
enum class	ControlResultCode : std::uint8_t { NotImplemented , NotBuilt , HostUnavailable , Inactive , PolicyDenied , GrantRequired , GrantExpired , ConsentRequired , LeaseConflict , StateConflict , SessionStale , InvalidRequest , DeadlineExceeded , Cancelled , CompletedAfterRevocation , UnknownNeedsRefresh , ResourceExhausted , InternalError }
enum class	ControlRetryClassification : std::uint8_t { Never , AfterRefresh , AfterGrant , AfterBackoff }
enum class	ControlProtocolError : std::uint8_t { None , EnvelopeTooLarge , Parse , RootType , UnknownField , MissingField , InvalidType , UnsupportedSchema , UnsupportedVersion , InvalidValue , LimitExceeded , HashMismatch }
enum class	ControlEnvelopeDirection : std::uint8_t { ClientToBroker , BrokerToClient , HostToBroker , BrokerToHost , HostToLauncher , LauncherToHost }
enum class	ControlJsonSchemaError : std::uint8_t { None , InvalidDocument , InvalidSchema , UnsupportedKeyword , LimitExceeded , ValidationFailed }
enum class	ControlServiceStatus : std::uint8_t { Responded , InvalidEnvelope , UnsupportedMessage , AdmissionDenied , ReceiptTransitionFailed , NegotiationRequired , ResourceExhausted }
enum class	ControlTelemetrySensitivity : std::uint8_t { Observable , Sensitive }
enum class	ControlTimelineDocumentSessionAction : std::uint8_t { Open , Apply , Diff , Undo , Redo }
	The action one dev.pulp.timeline/document-session@1 request selects. More...
enum class	ControlTrustedHostInventoryStatus { Prepared , PlatformUnavailable , InvalidRequest , UnsupportedArtifact , UnsafePath , SnapshotFailed , ManifestInvalid , ArtifactInvalid , SignatureInvalid , ResourceExhausted , EntropyUnavailable }
enum class	ControlTrustedHostLaunchStatus : std::uint8_t { Launched , InvalidConfiguration , InventoryUnavailable , SpawnFailed , PreflightRejected , EnrollmentRejected , BootstrapRejected }
enum class	EditorUrlSource { Default , Config , Environment }
	Source that produced the effective editor URL template — used by Inspector.getEditorUrlTemplate so clients can show which override is in force. More...
enum class	InspectorTargetedEventResult { Queued , QueuedAfterLossyEviction , DroppedLossy , ReliableOverflow , ClientNotFound , EventUnavailable , MessageTooLarge }
	Outcome of delivering one generation-scoped event to one authenticated transport client. More...
enum class	ControllerLeaseResult { Acquired , Renewed , HeldByOther , InvalidOwner }
enum class	MidiTestInputKind : std::uint8_t { NoteOn , NoteOff }
enum class	TestInputReleaseReason : std::uint8_t { ControllerReleased , ControllerExpired , ClientDisconnected , SessionTeardown }

Functions
std::string_view	queue_filename ()
	The canonical queue filename (beside .pulp-design-meta.json).
std::string	requests_to_json (const std::vector< AgentRequest > &requests)
	Serialize a request list to the canonical, stable JSON document.
std::optional< std::vector< AgentRequest > >	requests_from_json (std::string_view queue_json)
	Parse a queue document.
std::optional< std::string >	append_request (std::string_view queue_json, AgentRequest request)
	Append request to the queue encoded in queue_json, assigning a fresh id when request.id is empty (one greater than the largest numeric id present, starting at "1").
std::vector< AgentRequest >	pending_requests (std::string_view queue_json)
	The not-yet-consumed requests in queue_json, in order.
std::optional< std::pair< std::string, bool > >	ack_request (std::string_view queue_json, std::string_view id)
	Mark the request whose id is id consumed in queue_json.
std::string	queue_path (std::string_view project_dir)
	The queue file path inside project_dir.
std::optional< std::string >	enqueue_to_file (const std::string &path, AgentRequest request)
	Read + append + atomically rewrite the queue at path.
std::vector< AgentRequest >	read_pending_file (const std::string &path)
	The pending requests in the queue file at path (empty when the file is absent or unreadable).
bool	ack_in_file (const std::string &path, std::string_view id)
	Ack id in the queue file at path, rewriting atomically.
std::optional< std::vector< std::uint8_t > >	generate_inspector_secret ()
	Generate a per-session 256-bit token or per-connection 256-bit nonce.
std::optional< InspectorAuthChallenge >	make_inspector_auth_challenge (std::string session_id, std::string instance_id, std::string publication_id, std::string protocol_version)
std::optional< std::string >	make_inspector_auth_proof (std::span< const std::uint8_t > token, const InspectorAuthChallenge &challenge)
	Construct the versioned HMAC proof used by installed clients.
std::optional< std::string >	make_inspector_server_auth_proof (std::span< const std::uint8_t > token, const InspectorAuthChallenge &challenge, std::string_view client_proof)
	Construct and verify the distinct server-side transcript proof returned after the client proof succeeds.
bool	verify_inspector_server_auth_proof (std::span< const std::uint8_t > token, const InspectorAuthChallenge &challenge, std::string_view client_proof, std::string_view server_proof)
std::span< const InspectorCapabilityDescriptor >	inspector_capability_registry ()
std::string_view	capability_id (InspectorCapability capability)
std::string_view	capability_contract_id (InspectorCapability capability)
std::optional< InspectorCapability >	capability_from_id (std::string_view id)
std::optional< InspectorCapability >	capability_from_contract_id (std::string_view id)
std::string_view	capability_risk_id (InspectorCapabilityRisk risk)
std::string_view	side_effect_id (InspectorSideEffect side_effect)
std::string_view	executor_id (InspectorExecutor executor)
std::string_view	evidence_id (InspectorEvidence evidence)
std::string_view	profile_id (InspectorProfile profile)
std::optional< InspectorProfile >	profile_from_id (std::string_view id)
std::span< const InspectorCapability >	profile_capabilities (InspectorProfile profile)
std::span< const InspectorMethodDescriptor >	inspector_method_registry ()
const InspectorMethodDescriptor *	find_inspector_method (std::string_view method)
bool	capability_is_grantable (InspectorCapability capability)
InspectorCapabilityRisk	capability_risk (InspectorCapability capability)
bool	capability_requires_controller_lease (InspectorCapability capability)
bool	capability_requires_publication_binding (InspectorCapability capability)
bool	inspector_event_is_lossy (std::string_view method)
std::string_view	control_admission_status_id (ControlAdmissionStatus status)
std::optional< ControlAdmissionRequest >	control_admission_request (const ControlRequestEnvelope &envelope)
	Converts a strictly decoded wire request into the broker-owned admission request.
std::string_view	control_evidence_content_type (ControlEvidenceKind kind)
bool	control_evidence_contract_matches (ControlEvidenceKind kind, std::string_view content_type, ControlArtifactSensitivity sensitivity, ControlArtifactRedactionState redaction_state)
std::string_view	control_artifact_status_id (ControlArtifactStatus status)
std::string_view	control_artifact_deletion_reason_id (ControlArtifactDeletionReason reason)
std::filesystem::path	default_control_runtime_directory ()
	Deterministic owner-specific directory for the control carrier.
std::filesystem::path	default_control_runtime_directory (const std::filesystem::path &runtime_root)
	Deterministic control directory below an explicitly supplied runtime root.
std::filesystem::path	default_control_endpoint_path ()
	Deterministic LocalSocket endpoint for the control broker.
std::filesystem::path	default_control_endpoint_path (const std::filesystem::path &runtime_root)
bool	prepare_control_runtime_directory (const std::filesystem::path &runtime_directory)
	Create or validate an absolute owner-only runtime directory.
std::optional< ControlEndpointIdentity >	control_endpoint_identity (const std::filesystem::path &endpoint_path)
	Capture a socket only when its parent is private and its path is an owner-owned 0600 local endpoint.
bool	remove_stale_control_endpoint (const std::filesystem::path &endpoint_path, const ControlEndpointIdentity &expected_identity)
	Remove an endpoint only if its device and inode still match the identity captured before the caller's stale/liveness decision.
bool	remove_stale_control_endpoint (const std::filesystem::path &endpoint_path)
	Convenience for cleanup performed while the caller already holds the per-user daemon singleton and has established that the endpoint is stale.
ControlOperationExecutor	make_control_gpu_health_read_executor (ControlGpuHealthReadSourceResolver resolve_source)
	Creates the canonical dev.pulp.gpu/health.read@1 executor.
std::string_view	control_grant_status_id (ControlGrantStatus status)
ControlBrokerHealthProbeResult	probe_control_broker (const ControlHealthProbeConfig &config, std::chrono::milliseconds response_timeout=std::chrono::seconds(3))
	Performs an observational local carrier probe without opening a control session.
ControlHostBootstrapBytes	encode_control_host_bootstrap (const ControlHostBootstrapRecord &record)
std::optional< ControlHostBootstrapRecord >	decode_control_host_bootstrap (std::span< const std::uint8_t > bytes, std::chrono::system_clock::time_point now=std::chrono::system_clock::now(), ControlHostBootstrapDiagnostics *diagnostics=nullptr)
std::optional< ControlHostBootstrapRecord >	read_control_host_bootstrap (ControlHostBootstrapHandle handle, std::chrono::milliseconds timeout=std::chrono::seconds(3), std::chrono::system_clock::time_point now=std::chrono::system_clock::now(), ControlHostBootstrapDiagnostics *diagnostics=nullptr)
	Reads one bounded document to EOF, closes the inherited handle, and wipes the temporary encoded bytes on every path.
ControlHostBootstrapHandle	inherited_control_host_bootstrap_handle () noexcept
	Claims the private inherited standard-input handle.
std::optional< VerifiedControlPeerIdentity >	preflight_control_host (platform::ChildProcessInputChannel channel, std::int64_t expected_process_id, ControlPeerRole role, const ControlPeerVerifier &verifier, const ControlHostBootstrapProvider &provide_bootstrap, std::chrono::milliseconds timeout=std::chrono::seconds(3), ControlHostPreflightDiagnostics *diagnostics=nullptr)
std::optional< VerifiedControlPeerIdentity >	preflight_control_host (platform::ChildProcessInputChannel channel, std::int64_t expected_process_id, ControlPeerRole role, const ControlPeerVerifier &verifier, ControlHostBootstrapBytes bootstrap, std::chrono::milliseconds timeout=std::chrono::seconds(3), ControlHostPreflightDiagnostics *diagnostics=nullptr)
	Challenge the process on a private inherited channel, verify the kernel- observed peer after its response, then release an already-minted bootstrap.
std::optional< ControlHostBootstrapRecord >	receive_control_host_preflight (ControlHostBootstrapHandle handle, std::chrono::milliseconds timeout=std::chrono::seconds(3), std::optional< std::chrono::system_clock::time_point > now=std::nullopt, ControlHostPreflightDiagnostics *diagnostics=nullptr)
	Complete the child side of one inherited preflight and decode its bootstrap.
std::string_view	control_ui_input_disposition () noexcept
	Stable registry/documentation disposition for the UI-input contract.
std::string_view	control_host_tier_id (ControlHostTier tier)
std::string_view	control_identity_status_id (ControlIdentityStatus status)
std::filesystem::path	installed_control_broker_executable (const std::filesystem::path &client_executable)
	Resolve the peer-verification anchor for a broker installed beside a CLI or MCP client.
std::unique_ptr< InspectorControlSessionOpener >	make_installed_inspector_control_session_opener (std::filesystem::path client_executable, std::optional< std::string > exact_instance_id=std::nullopt, std::string legacy_profile="develop")
	Build the installed-process opener used by CLI and MCP compatibility adapters.
InspectorClientResult	request_control_inspector (InspectorControlSessionOpener &opener, std::string method, std::string params_json="{}", std::chrono::milliseconds timeout=std::chrono::seconds(3))
	Execute one already-supported trace Inspector method through the canonical capability-control carrier.
InspectorClientResult	request_control_inspector (std::string method, std::string params_json="{}", std::chrono::milliseconds timeout=std::chrono::seconds(3))
	Installed-process entry point for trace lifecycle adapters.
std::string_view	control_profile_id (ControlBuildProfile profile)
std::optional< ControlBuildProfile >	control_profile_from_id (std::string_view id)
std::string_view	control_manifest_error_id (ControlManifestError error)
std::string_view	control_denial_reason_id (ControlDenialReason reason)
std::span< const std::string_view >	control_permission_terms ()
ControlPermissionDecision	evaluate_control_permission (const ControlPermissionInputs &inputs)
bool	validate_control_manifest (const ControlManifest &manifest, std::string &error)
ControlManifestValidation	validate_control_manifest_detailed (const ControlManifest &manifest)
std::optional< ControlManifest >	parse_control_manifest (std::string_view json, ControlManifestDiagnostics *diagnostics=nullptr)
std::vector< std::filesystem::path >	control_sidecar_directories (const std::filesystem::path &executable_directory)
	Directories that may hold the control sidecars of an executable living in executable_directory (<name>.inspector-capabilities.json, <name>.
std::filesystem::path	control_sidecar_executable_directory (const std::filesystem::path &sidecar_directory)
	The directory of the executable a sidecar in sidecar_directory describes: <bundle>/Contents/MacOS for a macOS bundle's Contents/Resources, and the directory itself otherwise.
std::string	serialize_control_manifest (const ControlManifest &manifest)
	Emits the unique stable byte representation used for artifact digests.
std::string	control_manifest_digest (const ControlManifest &manifest)
std::string	control_consent_identity (std::string_view manifest_digest, std::string_view artifact_digest)
ControlArtifactValidation	validate_control_artifact_bytes (std::string_view bytes, const ControlArtifactExpectation &expectation)
	Validates the immutable markers embedded in one exact executable snapshot.
std::span< const ControlOperationDescriptor >	control_operation_registry ()
const ControlOperationDescriptor *	resolve_control_operation (std::string_view id, std::uint32_t version)
std::string	serialize_control_registry ()
	Canonical projection of capability metadata and adapter operations.
ControlOperationExecutor	make_control_offline_render_executor (format::ProcessorFactory factory, ControlOfflineRenderSourceResolver resolve_source, ControlOfflineRenderClock clock={})
	Creates the canonical dev.pulp.render/offline@1 T0 executor.
std::string_view	control_operation_store_status_id (ControlOperationStoreStatus status)
std::optional< ControlPeerEvidence >	observe_control_peer (const events::InterprocessConnection &connection, ControlPeerRole role)
	Observe one connected OS-local peer through kernel credentials plus the platform process-generation and code-signing APIs.
std::optional< ControlPeerEvidence >	observe_suspended_control_process (std::int64_t process_id, ControlPeerRole role)
	Observe a newly spawned macOS process while it is still kernel-suspended.
std::optional< VerifiedControlPeerIdentity >	verify_control_peer (const events::InterprocessConnection &connection, const ControlPeerExpectation &expectation)
	Mint a verified identity only when the live carrier evidence exactly matches the broker-owned expectation.
ControlProcessLiveness	control_peer_process_liveness (const ControlPeerEvidence &evidence)
	Conservatively reports whether the kernel process behind previously observed peer evidence is still live.
ControlNegotiationResult	negotiate_control_protocol (const ControlNegotiationOffer &local, const ControlNegotiationOffer &peer, std::uint32_t local_security_floor=kControlProtocolVersion)
	Selects the highest common revision at or above local_security_floor.
bool	control_envelope_allowed (const ControlEnvelope &envelope, ControlEnvelopeDirection direction)
	Direction is transport state, not payload authority.
bool	validate_control_json_schema (std::string_view instance_json, std::string_view schema_json, ControlJsonSchemaDiagnostics *diagnostics=nullptr)
	Validates an untrusted JSON instance against the bounded JSON Schema subset used by Product A operation descriptors.
bool	validate_control_output_json_schema (std::string_view instance_json, std::string_view schema_json, ControlJsonSchemaDiagnostics *diagnostics=nullptr)
	Validates an operation result using the larger, still-bounded result budget.
std::string_view	control_negotiation_status_id (ControlNegotiationStatus status)
std::string_view	control_receipt_state_id (ControlReceiptState state)
std::string_view	control_result_code_id (ControlResultCode code)
std::string_view	control_retry_classification_id (ControlRetryClassification retry)
bool	control_receipt_state_is_terminal (ControlReceiptState state)
bool	valid_control_receipt_transition (ControlReceiptState from, ControlReceiptState to)
bool	valid_control_progress_transition (const ControlProgressEnvelope &previous, const ControlProgressEnvelope &next)
	Checks that a later observation belongs to the same admitted operation and advances both sequence and completed work without changing the total.
std::optional< std::string >	canonicalize_control_json (std::string_view json)
	Canonicalizes an arbitrary JSON value by recursively sorting object keys.
std::optional< std::string >	control_request_hash (const ControlRequestEnvelope &request)
	Hashes the authority and operation binding plus canonical request parameters.
std::optional< std::string >	encode_control_legacy_inspector_error (const ControlLegacyInspectorError &error)
	Encodes/decodes the strict compatibility object carried in a failed adapter receipt's detail_json.
std::optional< ControlLegacyInspectorError >	decode_control_legacy_inspector_error (std::string_view detail_json)
std::string	encode_control_envelope (const ControlEnvelope &envelope)
	Emits one deterministic JSON representation.
std::optional< ControlEnvelope >	decode_control_envelope (std::string_view json, ControlProtocolDiagnostics *diagnostics=nullptr)
ControlExecutionOutcome	execute_control_instance_read (ControlBroker &broker, const ControlAdmissionPlan &plan, const ControlRequestEnvelope &request, const ControlExecutionContext &context)
	Broker-local executor for dev.pulp.instance/read@1.
ControlOperationExecutor	make_control_sample_region_edit_executor (ControlSampleRegionTargetResolver)
ControlOperationExecutor	make_control_sample_region_read_executor (ControlSampleRegionTargetResolver)
ControlOperationExecutor	make_control_sequencer_state_read_executor (ControlSequencerStateTargetResolver resolve_target)
	Implements dev.pulp.sequencer/state.read@1.
ControlOperationExecutor	make_control_sequencer_state_edit_executor (ControlSequencerStateTargetResolver resolve_target)
	Implements dev.pulp.sequencer/state.edit@1.
ControlOperationExecutor	make_control_sequencer_transport_read_executor (ControlSequencerTransportTargetResolver resolve_target)
	Implements dev.pulp.sequencer/transport.loop.read@1.
ControlOperationExecutor	make_control_sequencer_transport_write_executor (ControlSequencerTransportTargetResolver resolve_target)
	Implements dev.pulp.sequencer/transport.loop.write@1.
std::string_view	control_service_status_id (ControlServiceStatus status)
ControlOperationExecutor	make_control_signal_graph_executor (ControlSignalGraphAuthorityResolver resolve)
std::unique_ptr< format::StandaloneControlHost >	make_control_standalone_host ()
	Creates the canonical broker-enrolled host bridge for an explicitly control-enabled Standalone executable.
ControlOperationExecutor	make_control_state_read_executor (ControlStateReadSourceResolver resolve_source)
	Creates the canonical dev.pulp.state/read@1 T0/T1 executor.
ControlOperationExecutor	make_control_state_write_executor (ControlStateWriteTargetResolver resolve_target)
	Implements dev.pulp.state/parameter-gesture@1.
std::string_view	control_timeline_document_session_action_name (ControlTimelineDocumentSessionAction action) noexcept
	Returns the stable public name of action, as the JSON schema spells it.
std::optional< ControlTimelineDocumentSessionAction >	control_timeline_document_session_action_by_name (std::string_view name) noexcept
	Resolves an action from its public name, or nullopt for an unknown name.
ControlResultCode	control_timeline_conflict_result_code (pulp::timeline::ConflictCode conflict) noexcept
	Projects a session-side conflict onto the broker result code.
ControlRetryClassification	control_timeline_conflict_retry (pulp::timeline::ConflictCode conflict) noexcept
	Returns how a caller may retry a request refused with conflict.
std::optional< std::string >	control_timeline_admissible_writer_profile (std::string_view requested) noexcept
	Returns the writer-profile name the broker admits for requested.
ControlOperationExecutor	make_control_timeline_document_session_executor (ControlTimelineDocumentSessionSourceResolver resolve_source)
	Creates the canonical dev.pulp.timeline/document-session@1 executor.
std::string_view	control_trusted_host_inventory_status_id (ControlTrustedHostInventoryStatus status)
std::optional< ControlTrustedHostPreparationPolicy >	pin_control_trusted_host_preparation_policy (const ControlTrustedHostLaunchIntent &intent)
	Pins the exact raw-host bytes, manifest, working directory, and adjacent native runtime closure selected by trusted broker policy.
std::string_view	control_trusted_host_launch_status_id (ControlTrustedHostLaunchStatus status)
std::string	format_editor_url (std::string_view tmpl, std::string_view path, int line, std::optional< int > col=std::nullopt)
	Substitute {path}, {line}, and {col} in tmpl with the supplied values.
bool	validate_editor_url_template (std::string_view tmpl, std::string *error_out=nullptr)
	Validate a candidate editor URL template.
std::optional< std::string >	editor_url_env_override ()
	Look up the environment override (PULP_INSPECTOR_EDITOR_URL).
EffectiveEditorUrl	effective_editor_url (const InspectorConfig &config)
std::string_view	editor_url_source_name (EditorUrlSource source)
	Stringify the source enum for protocol responses.
bool	apply_move_tweak_to_view (View &view, std::string_view property_path, const choc::value::Value &value)
	Move-tweak namespace bridge.
BadgePlacement	compute_badge_placement (float sel_x, float sel_y, float sel_h, float badge_w, float badge_h, float root_w, float gap=5.0f, float top_margin=0.0f)
	Place a badge of size (`badge_w` × `badge_h`) for a selection whose top-left is at (`sel_x`, `sel_y`) with height `sel_h`.
void	install_inspector_hooks (InspectorOverlay &inspector)
	Install the inspector into the View system's paint and input hooks.
void	uninstall_inspector_hooks ()
	Tear down what install_inspector_hooks() set up: nulls g_active_inspector and releases all five View hook slots.
std::string	encode_message (const InspectorMessage &msg)
	Serialize a message to a JSON string.
bool	decode_message (const std::string &json, InspectorMessage &out)
	Parse a JSON string into a message. Returns false on parse failure.
InspectorMessage	make_request (int64_t id, std::string method, std::string params_json="{}")
InspectorMessage	make_response (int64_t id, std::string result_json)
InspectorMessage	make_error (int64_t id, std::string error_message, std::string error_code="internal_error", std::string error_data_json="{}")
InspectorMessage	make_event (std::string method, std::string params_json="{}")
std::unique_ptr< RuntimeEvaluator >	make_script_runtime_evaluator (view::ScriptInspectorBridge *bridge)
	Construct the separately linked high-risk adapter for a live scripted UI.
std::unique_ptr< RuntimeEvaluator >	make_script_runtime_evaluator (ScriptedUiSessionVisitor visit_session)
SourceJumpResult	resolve_source_jump (const InspectorConfig &config, const pulp::view::View *view)
	Resolve the source-jump target for view using config's editor URL template (with environment override applied).
bool	launch_editor_url (std::string_view url, std::string *error=nullptr)
	Hand an editor URL to the OS handler.
SourceJumpResult	jump_to_source (const InspectorConfig &config, const pulp::view::View *view, bool dry_run)
	Convenience: resolve + launch in one call.

Variables
constexpr std::size_t	inspector_token_size = 32
constexpr std::size_t	inspector_nonce_size = 32
constexpr std::size_t	kControlMaximumConnectionAdmissions = 1024
constexpr auto	kControlMaximumConnectionAdmissionTtl = std::chrono::seconds(30)
constexpr std::uint32_t	kControlHostBootstrapVersion = 1
	Transport primitives for a record already minted by broker-owned enrollment.
constexpr std::string_view	kControlHostBootstrapSchema = "dev.pulp.control/host-bootstrap@1"
constexpr std::size_t	kControlHostBootstrapMaximumBytes = 16u * 1024u
constexpr std::size_t	kControlDevelopmentMaximumTextBytes = 4096
constexpr std::size_t	kControlMaximumHostEnrollments = 1024
constexpr auto	kControlMaximumHostEnrollmentTtl = std::chrono::seconds(30)
constexpr std::size_t	kControlCaptureMaximumBytes = 16u * 1024u * 1024u
constexpr std::size_t	kControlRuntimeEvalMaximumResultBytes = 256u * 1024u
constexpr std::size_t	kControlUiMaximumTargetBytes = 256
constexpr std::size_t	kControlUiMaximumViewGenerationBytes = 128
constexpr std::size_t	kControlUiMaximumKeyBytes = 64
constexpr std::size_t	kControlUiMaximumTextBytes = 4096
constexpr double	kControlUiMaximumCoordinate = 1'000'000.0
constexpr std::uint32_t	kControlManifestSchemaVersion = 1
constexpr std::string_view	kControlManifestSchemaId = "dev.pulp.control/artifact-manifest@1"
constexpr std::string_view	kControlRegistryDigest = "d98850681408945533dff4b647ddf0309f500cdbafc13f4af983ba4674410e8e"
constexpr std::uint32_t	kControlOperationReceiptSchemaVersion = 1
constexpr std::string_view	kControlOperationReceiptSchemaId
constexpr std::uint32_t	kControlAuthorityBindingVersion = 1
constexpr std::uint32_t	kControlProtocolVersion = 1
constexpr std::string_view	kControlEnvelopeSchema = "dev.pulp.control/envelope@1"
constexpr std::string_view	kControlLegacyInspectorJsonEncoding = "legacy-inspector-json-v1"
constexpr std::size_t	kControlMaximumRequestPayloadBytes = 512u * 1024u
constexpr std::size_t	kControlMaximumEnvelopeBytes = 2u * 1024u * 1024u
constexpr std::size_t	kControlHostMaximumArtifactPublications = 1
constexpr std::size_t	kControlHostMaximumArtifactPublicationBytes = 1u * 1024u * 1024u
constexpr std::size_t	kControlMaximumResultDetailBytes = 1600u * 1024u
constexpr std::size_t	kControlReceiptMaximumRequestIdBytes = 128
	Receipt normalization and wire encoding use these same field boundaries.
constexpr std::size_t	kControlReceiptMaximumOperationIdBytes = 256
constexpr std::size_t	kControlReceiptMaximumExplanationBytes = 1024
constexpr std::size_t	kControlReceiptMaximumCancellationReasonBytes = 1024
constexpr std::size_t	kControlReceiptMaximumArtifacts = 64
constexpr std::size_t	kControlReceiptMaximumArtifactIdBytes = 128
constexpr std::size_t	kControlReceiptMaximumArtifactMediaTypeBytes = 128
constexpr std::size_t	kControlReceiptMaximumEvidenceIds = 64
constexpr std::size_t	kControlReceiptMaximumEvidenceIdBytes = 128
constexpr std::size_t	kControlMaximumArtifactReadBytes = 1024u * 1024u
constexpr std::size_t	kControlMaximumArtifactChunkBase64Bytes
constexpr std::size_t	kControlMaximumStatusIdBytes = 64
constexpr std::size_t	kControlMaximumErrorCodeBytes = 128
constexpr std::size_t	kControlMaximumSdkVersionBytes = 128
constexpr std::size_t	kControlMaximumArtifactMetadataFieldBytes = 512
constexpr std::size_t	kControlMaximumArtifactContentTypeBytes = 256
constexpr std::size_t	kControlHostPreflightMaximumBootstrapBase64Bytes = 24u * 1024u
InspectorOverlay *	g_active_inspector = nullptr
	Global inspector instance for the current window.
constexpr std::size_t	kInspectorExtendedMessageBytes
	Bounded transfer ceiling used by clients and by hosts that expose image capture.
constexpr std::size_t	kRuntimeEvalMaxCodeBytes = 64u * 1024u
constexpr std::size_t	kRuntimeEvalMaxResultBytes = 1024u * 1024u
constexpr std::size_t	kRuntimeEvalMaxResponseBytes = 1024u * 1024u
constexpr std::chrono::milliseconds	kRuntimeEvalDeadline {2000}

Typedef Documentation

◆ ControlAdmissionConsumer

using pulp::inspect::ControlAdmissionConsumer

Initial value:

std::function<std::optional<ControlConnectionAdmission>(std::string_view admission_id)>

◆ ControlArtifactPublisher

using pulp::inspect::ControlArtifactPublisher

Initial value:

std::function<ControlArtifactStoreResult(

std::span<const std::uint8_t>, ControlArtifactPublication)>

pulp::inspect::ControlArtifactPublication

Definition control_execution.hpp:28

pulp::inspect::ControlArtifactStoreResult

Definition control_artifacts.hpp:141

◆ ControlClientNegotiationResult

using pulp::inspect::ControlClientNegotiationResult = ControlDispatchResult<ControlNegotiationResult>

◆ ControlClientReceiptResult

using pulp::inspect::ControlClientReceiptResult = ControlDispatchResult<ControlReceiptEnvelope>

◆ ControlConnectionPrincipal

using pulp::inspect::ControlConnectionPrincipal

Initial value:

std::variant<ControlClientConnectionPrincipal, ControlHostConnectionPrincipal>

◆ ControlDeferredCompletion

using pulp::inspect::ControlDeferredCompletion = std::function<void(ControlExecutionOutcome)>

◆ ControlEnvelopePayload

using pulp::inspect::ControlEnvelopePayload

Initial value:

 
    std::variant<ControlNegotiationOffer, ControlNegotiationResult, ControlRequestEnvelope,
                 ControlCancelEnvelope, ControlProgressEnvelope, ControlReceiptEnvelope,
                 ControlSessionOpenEnvelope, ControlSessionOpenResult, ControlManagementEnvelope,
                 ControlManagementResult, ControlArtifactReadEnvelope,
                 ControlArtifactReadResponseEnvelope, ControlHealthEnvelope, ControlHealthResult,
                 ControlErrorEnvelope, ControlHostOpenEnvelope, ControlHostOpenResult,
                 ControlHostReadyEnvelope, ControlHostReadyResult,
                 ControlHostHeartbeatEnvelope, ControlHostHeartbeatResult,
                 ControlHostPreflightChallengeEnvelope, ControlHostPreflightResponseEnvelope,
                 ControlHostPreflightBootstrapEnvelope, ControlHostPreflightReceiptEnvelope,
                 ControlHostExecuteEnvelope,
                 ControlHostProgressEnvelope, ControlHostCancelEnvelope,
                 ControlHostAuthorityEndEnvelope,
                 ControlHostCompleteEnvelope>

◆ ControlExecutionGuard

using pulp::inspect::ControlExecutionGuard = std::function<ControlExecutionCheckpoint()>

◆ ControlGpuHealthReadSourceResolver

using pulp::inspect::ControlGpuHealthReadSourceResolver

Initial value:

std::function<std::optional<ControlGpuHealthReadSource>(const ControlAdmissionPlan&)>

pulp::inspect::ControlAdmissionPlan

Immutable authority snapshot minted by ControlBroker after all seven permission terms pass.

Definition control_admission.hpp:58

◆ ControlHostBootstrapHandle

using pulp::inspect::ControlHostBootstrapHandle = int

◆ ControlHostBootstrapProvider

using pulp::inspect::ControlHostBootstrapProvider

Initial value:

std::function<ControlHostBootstrapBytes(const VerifiedControlPeerIdentity&)>

pulp::inspect::ControlHostBootstrapBytes

Definition control_host_bootstrap.hpp:70

pulp::inspect::VerifiedControlPeerIdentity

Copyable proof minted only by the broker's trusted OS peer verifier.

Definition control_identity.hpp:63

Mints one bootstrap only after the inherited channel has proven the exact live child.

Returning an empty value rejects the launch without releasing authority to the host.

◆ ControlMotionTargetResolver

using pulp::inspect::ControlMotionTargetResolver

Initial value:

std::function<std::optional<ControlMotionTarget>(const ControlAdmissionPlan&)>

◆ ControlOfflineRenderClock

using pulp::inspect::ControlOfflineRenderClock

Initial value:

std::function<std::chrono::steady_clock::time_point()>

◆ ControlOfflineRenderSourceResolver

using pulp::inspect::ControlOfflineRenderSourceResolver

Initial value:

 
    std::function<std::optional<ControlOfflineRenderSource>(
        const ControlAdmissionPlan&, std::string_view input_artifact_id)>

◆ ControlOperationExecutor

using pulp::inspect::ControlOperationExecutor

Initial value:

std::function<ControlExecutionOutcome(

const ControlAdmissionPlan&, const ControlRequestEnvelope&, const ControlExecutionContext&)>

pulp::inspect::ControlExecutionContext

Definition control_execution.hpp:38

pulp::inspect::ControlExecutionOutcome

Definition control_execution.hpp:14

Trusted in-process adapter contract.

An executor must never wait past the plan deadline itself: it either completes within the bound or promptly returns deferred = true and later invokes complete_deferred. The service cannot safely preempt arbitrary C++ running in its process. The supplied main-thread adapter enforces this contract with a fenced, bounded RPC.

◆ ControlProgressReporter

using pulp::inspect::ControlProgressReporter

Initial value:

std::function<bool(std::uint64_t current, std::uint64_t total, std::string detail_json)>

◆ ControlRuntimeEvalRedactor

using pulp::inspect::ControlRuntimeEvalRedactor

Initial value:

std::function<std::optional<std::string>(std::string_view result_json)>

◆ ControlSampleRegionTargetResolver

using pulp::inspect::ControlSampleRegionTargetResolver

Initial value:

std::function<std::shared_ptr<ControlSampleRegionTarget>(const ControlAdmissionPlan&)>

◆ ControlSequencerStateTargetResolver

using pulp::inspect::ControlSequencerStateTargetResolver

Initial value:

std::function<std::optional<ControlSequencerStateTarget>(const ControlAdmissionPlan&)>

◆ ControlSequencerTransportTargetResolver

using pulp::inspect::ControlSequencerTransportTargetResolver

Initial value:

std::function<std::optional<ControlSequencerTransportTarget>(const ControlAdmissionPlan&)>

◆ ControlSignalGraphAuthorityResolver

using pulp::inspect::ControlSignalGraphAuthorityResolver

Initial value:

std::function<pulp::host::SignalGraphControlAuthority*(const ControlAdmissionPlan&)>

pulp::host::SignalGraphControlAuthority

The sole host-side authority for live graph modulation-route lifecycle.

Definition signal_graph_control.hpp:56

◆ ControlStateReadSourceResolver

using pulp::inspect::ControlStateReadSourceResolver

Initial value:

std::function<std::optional<ControlStateReadSource>(const ControlAdmissionPlan&)>

◆ ControlStateWriteTargetResolver

using pulp::inspect::ControlStateWriteTargetResolver

Initial value:

std::function<std::optional<ControlStateWriteTarget>(const ControlAdmissionPlan&)>

◆ ControlTimelineDocumentSessionSourceResolver

using pulp::inspect::ControlTimelineDocumentSessionSourceResolver

Initial value:

std::function<std::optional<ControlTimelineDocumentSessionSource>(const ControlAdmissionPlan&)>

◆ ControlUiAuthorityResolver

using pulp::inspect::ControlUiAuthorityResolver

Initial value:

std::function<std::optional<ControlUiProjectedAuthority>(const ControlAdmissionPlan&)>

◆ ControlUiInput

using pulp::inspect::ControlUiInput

Initial value:

std::variant<ControlUiPointerInput, ControlUiKeyboardInput,

ControlUiFocusInput, ControlUiTextInput>

pulp::inspect::ControlUiFocusInput

Definition control_host_ui_executor.hpp:77

pulp::inspect::ControlUiKeyboardInput

Definition control_host_ui_executor.hpp:70

pulp::inspect::ControlUiPointerInput

Definition control_host_ui_executor.hpp:62

pulp::inspect::ControlUiTextInput

Definition control_host_ui_executor.hpp:81

◆ InspectorEventRetirementSink

using pulp::inspect::InspectorEventRetirementSink

Initial value:

std::function<void(

std::string_view client_id, std::string_view loss_owner)>

◆ InspectorEventSink

using pulp::inspect::InspectorEventSink = std::function<void(const InspectorMessage&)>

◆ InspectorTargetedEventSink

using pulp::inspect::InspectorTargetedEventSink

Initial value:

std::function<InspectorTargetedEventResult(

std::string_view client_id, const InspectorMessage& event, std::string_view loss_owner)>

pulp::inspect::InspectorTargetedEventResult

InspectorTargetedEventResult

Outcome of delivering one generation-scoped event to one authenticated transport client.

Definition inspector_delivery.hpp:20

pulp::inspect::InspectorMessage

A single inspector protocol message (request, response, or event).

Definition protocol.hpp:18

◆ ScriptedUiSessionVisitor

using pulp::inspect::ScriptedUiSessionVisitor

Initial value:

std::function<void(

const std::function<void(view::ScriptedUiSession*)>&)>

pulp::view::ScriptedUiSession

Definition scripted_ui.hpp:125

Construct a reload-safe evaluator that borrows the current scripted realm only for each bounded evaluator call.

Enumeration Type Documentation

◆ ControlAdmissionStatus

enum class pulp::inspect::ControlAdmissionStatus : std::uint8_t

strong

Enumerator
Admitted
InvalidRequest
UnknownOperation
IdentityMismatch
ArtifactLineageRequired
PermissionDenied
DurableStoreUnavailable
IdempotencyConflict
RequestIdConflict
ReplayWindowExpired
ResourceExhausted
DeadlineExceeded
CancelledBeforeDispatch

◆ ControlArtifactDeletionReason

enum class pulp::inspect::ControlArtifactDeletionReason : std::uint8_t

strong

Enumerator
Expired
QuotaCollection
ExplicitDeletion
CrashCleanup

◆ ControlArtifactDeletionState

enum class pulp::inspect::ControlArtifactDeletionState : std::uint8_t

strong

Enumerator
Active
Deleted

◆ ControlArtifactRedactionState

enum class pulp::inspect::ControlArtifactRedactionState : std::uint8_t

strong

Enumerator
Original
Redacted

◆ ControlArtifactSensitivity

enum class pulp::inspect::ControlArtifactSensitivity : std::uint8_t

strong

Enumerator
Public
Internal
Sensitive
Restricted

◆ ControlArtifactStatus

enum class pulp::inspect::ControlArtifactStatus : std::uint8_t

strong

Enumerator
Stored
Read
InvalidRequest
Unauthorized
NotFound
Corrupt
ResourceExhausted
IoError

◆ ControlBrokerHealthProbeStatus

enum class pulp::inspect::ControlBrokerHealthProbeStatus : std::uint8_t

strong

Enumerator
Unavailable
ReachableUnverified
HealthyVerified
Incompatible
Malformed

◆ ControlBuildProfile

enum class pulp::inspect::ControlBuildProfile : std::uint8_t

strong

Enumerator
ProductionStripped
DeveloperLocal
TestDeterministic
SupportDiagnostics
ResearchUnsafe

◆ ControlConnectionAdmissionStatus

enum class pulp::inspect::ControlConnectionAdmissionStatus : std::uint8_t

strong

Enumerator
Issued
InvalidRequest
ResourceExhausted
EntropyUnavailable

◆ ControlConsentAuthority

enum class pulp::inspect::ControlConsentAuthority : std::uint8_t

strong

Enumerator
None
TrustedPulpCli
TrustedHostUi
BrokerUserPrompt
ExistingUserPolicy
PluginUi
AgentClient

◆ ControlConsentPromptResult

enum class pulp::inspect::ControlConsentPromptResult : std::uint8_t

strong

Enumerator
Approved
Denied
TimedOut
Unavailable

◆ ControlDenialReason

enum class pulp::inspect::ControlDenialReason : std::uint8_t

strong

Enumerator
UnknownCapability
NotImplemented
NotBuilt
HostUnavailable
NotActivated
PolicyIneligible
ClientNotGranted
SessionNotLive
ProfileForbidden
UnsupportedExecutor
PublicationMismatch

◆ ControlDiagnosticSeverity

enum class pulp::inspect::ControlDiagnosticSeverity : std::uint8_t

strong

Enumerator
Info
Warning
Error

◆ ControlDurableClientLifetime

enum class pulp::inspect::ControlDurableClientLifetime : std::uint8_t

strong

Enumerator
Broker
Process

◆ ControlEnvelopeDirection

enum class pulp::inspect::ControlEnvelopeDirection : std::uint8_t

strong

Enumerator
ClientToBroker
BrokerToClient
HostToBroker
BrokerToHost
HostToLauncher
LauncherToHost

◆ ControlEvidenceKind

enum class pulp::inspect::ControlEvidenceKind : std::uint8_t

strong

Enumerator
Screenshot
OfflineRender
StateSnapshot
PerfettoTrace

◆ ControlExecutionCheckpoint

enum class pulp::inspect::ControlExecutionCheckpoint : std::uint8_t

strong

Enumerator
Continue
Cancelled
DeadlineExceeded
AuthorityRevoked

◆ ControlGrantSelectorKind

enum class pulp::inspect::ControlGrantSelectorKind : std::uint8_t

strong

Enumerator
Profile
Operation

◆ ControlGrantStatus

enum class pulp::inspect::ControlGrantStatus : std::uint8_t

strong

Enumerator
Granted
InvalidRequest
BrokerMismatch
ClientUnavailable
RegistrationUnavailable
ConsentRequired
ConsentReplay
CapabilityUnavailable
ResourceExhausted
NotFound
Expired
Revoked

◆ ControlHostBootstrapStatus

enum class pulp::inspect::ControlHostBootstrapStatus : std::uint8_t

strong

Enumerator
Accepted
Absent
Truncated
Oversize
InvalidRecord
UnsupportedVersion
Expired
ReadFailed

◆ ControlHostEnrollmentStatus

enum class pulp::inspect::ControlHostEnrollmentStatus : std::uint8_t

strong

Enumerator
Created
InvalidRequest
ResourceExhausted
EntropyUnavailable

◆ ControlHostPreflightStatus

enum class pulp::inspect::ControlHostPreflightStatus : std::uint8_t

strong

Private transport preflight for an already-spawned host.

It authenticates the writer of the inherited carrier but does not register or admit it.

Enumerator
Accepted
Unsupported
InvalidChannel
EntropyUnavailable
Timeout
MalformedMessage
DirectionMismatch
NonceMismatch
PeerUnavailable
ProcessMismatch
AuthorityRejected
SendFailed
BootstrapInvalid

◆ ControlHostTier

enum class pulp::inspect::ControlHostTier : std::uint8_t

strong

Enumerator
OfflineJob
Standalone
SharedPluginHost

◆ ControlIdentityStatus

enum class pulp::inspect::ControlIdentityStatus : std::uint8_t

strong

Enumerator
Accepted
InvalidRequest
PeerRoleMismatch
HostUnavailable
AttestationUnavailable
IdentityMismatch
NotFound
Expired
Replay
ResourceExhausted
EntropyUnavailable

◆ ControlJsonSchemaError

enum class pulp::inspect::ControlJsonSchemaError : std::uint8_t

strong

Enumerator
None
InvalidDocument
InvalidSchema
UnsupportedKeyword
LimitExceeded
ValidationFailed

◆ ControllerLeaseResult

enum class pulp::inspect::ControllerLeaseResult

strong

Enumerator
Acquired
Renewed
HeldByOther
InvalidOwner

◆ ControlManifestError

enum class pulp::inspect::ControlManifestError : std::uint8_t

strong

Enumerator
None
Parse
RootType
UnknownField
MissingOrInvalidField
UnsupportedSchema
VersionDowngrade
VersionTooNew
UnknownProfile
PermissionTermsMismatch
CapabilityLimit
UnknownCapability
InvalidCapabilitySet
MissingCapabilityDependency
ProfileViolation
InvalidProfile
InvalidIdentity
RegistryMismatch
EndpointMismatch
UnsafeAcknowledgementMismatch

◆ ControlNegotiationStatus

enum class pulp::inspect::ControlNegotiationStatus : std::uint8_t

strong

Enumerator
Accepted
InvalidOffer
NoCommonVersion
DowngradeRejected
UnsupportedMandatoryFeature

◆ ControlOperationAuthorizationKind

enum class pulp::inspect::ControlOperationAuthorizationKind : std::uint8_t

strong

Enumerator
Reusable
ProvisionalOneShot
CommittedOneShot

◆ ControlOperationStoreStatus

enum class pulp::inspect::ControlOperationStoreStatus : std::uint8_t

strong

Enumerator
Opened
Admitted
Replay
ReplayWindowExpired
Transitioned
CancellationRequested
IdempotencyConflict
RequestIdConflict
InvalidRequest
InvalidTransition
NotFound
ResourceExhausted
StoreUnavailable
MalformedStore
PersistenceError

◆ ControlPeerRole

enum class pulp::inspect::ControlPeerRole : std::uint8_t

strong

Enumerator
Client
OfflineHost
StandaloneHost
TrustedHostBridge

◆ ControlProcessLiveness

enum class pulp::inspect::ControlProcessLiveness : std::uint8_t

strong

Enumerator
Unknown
Alive
Dead

◆ ControlProtocolError

enum class pulp::inspect::ControlProtocolError : std::uint8_t

strong

Enumerator
None
EnvelopeTooLarge
Parse
RootType
UnknownField
MissingField
InvalidType
UnsupportedSchema
UnsupportedVersion
InvalidValue
LimitExceeded
HashMismatch

◆ ControlReceiptState

enum class pulp::inspect::ControlReceiptState : std::uint8_t

strong

Enumerator
Admitted
Running
Completed
Failed
Cancelled
CompletedAfterRevocation
UnknownNeedsRefresh

◆ ControlResultCode

enum class pulp::inspect::ControlResultCode : std::uint8_t

strong

Enumerator
NotImplemented
NotBuilt
HostUnavailable
Inactive
PolicyDenied
GrantRequired
GrantExpired
ConsentRequired
LeaseConflict
StateConflict
SessionStale
InvalidRequest
DeadlineExceeded
Cancelled
CompletedAfterRevocation
UnknownNeedsRefresh
ResourceExhausted
InternalError

◆ ControlRetryClassification

enum class pulp::inspect::ControlRetryClassification : std::uint8_t

strong

Enumerator
Never
AfterRefresh
AfterGrant
AfterBackoff

◆ ControlSecurityOutcome

enum class pulp::inspect::ControlSecurityOutcome : std::uint8_t

strong

Enumerator
Accepted
Denied
Revoked
Expired

◆ ControlServiceStatus

enum class pulp::inspect::ControlServiceStatus : std::uint8_t

strong

Enumerator
Responded
InvalidEnvelope
UnsupportedMessage
AdmissionDenied
ReceiptTransitionFailed
NegotiationRequired
ResourceExhausted

◆ ControlTelemetrySensitivity

enum class pulp::inspect::ControlTelemetrySensitivity : std::uint8_t

strong

Enumerator
Observable
Sensitive

◆ ControlTimelineDocumentSessionAction

enum class pulp::inspect::ControlTimelineDocumentSessionAction : std::uint8_t

strong

The action one dev.pulp.timeline/document-session@1 request selects.

One capability carries one operation, so the mutable-document surface is a single operation discriminated by action rather than five capabilities that would each need their own grant.

Enumerator
Open	Opens a mutable session over a canonical project and registers a writer.
Apply	Submits one transaction of commands against an open session.
Diff	Reads the accumulated change set of an open session.
Undo	Reverts the newest closed undo group.
Redo	Reapplies the newest redo group.

◆ ControlTrustedHostInventoryStatus

enum class pulp::inspect::ControlTrustedHostInventoryStatus

strong

Enumerator
Prepared
PlatformUnavailable
InvalidRequest
UnsupportedArtifact
UnsafePath
SnapshotFailed
ManifestInvalid
ArtifactInvalid
SignatureInvalid
ResourceExhausted
EntropyUnavailable

◆ ControlTrustedHostLaunchStatus

enum class pulp::inspect::ControlTrustedHostLaunchStatus : std::uint8_t

strong

Enumerator
Launched
InvalidConfiguration
InventoryUnavailable
SpawnFailed
PreflightRejected
EnrollmentRejected
BootstrapRejected

◆ ControlUiApplyStatus

enum class pulp::inspect::ControlUiApplyStatus : std::uint8_t

strong

Enumerator
Applied
TargetUnavailable
StaleGeneration
InvalidEvent

◆ EditorUrlSource

enum class pulp::inspect::EditorUrlSource

strong

Source that produced the effective editor URL template — used by Inspector.getEditorUrlTemplate so clients can show which override is in force.

Enumerator
Default	Built-in fallback (vscode://file/{path}:{line}).
Config	Set via InspectorConfig / setEditorUrlTemplate.
Environment	Overridden by PULP_INSPECTOR_EDITOR_URL.

◆ InspectorAuditOutcome

enum class pulp::inspect::InspectorAuditOutcome : std::uint8_t

strong

Enumerator
Denied
Applied
Rejected

◆ InspectorCapability

enum class pulp::inspect::InspectorCapability : std::uint8_t

strong

Enumerator
SessionDescribe
SessionControl
StateRead
GpuHealthRead
RenderOffline
UiRead
DiagnosticsRead
LogsRead
CaptureImage
UiInput
TraceControl
TraceSessionControl
StateWrite
TestInput
AuthoringTweaks
TelemetryStream
RuntimeReload
RuntimeEval
ArtifactRead
SequencerStateRead
SequencerStateEdit
SequencerTransportRead
SequencerTransportWrite
TimelineDocumentSession
GraphSampleRegionRead
GraphSampleRegionEdit
ModulationRouteEdit
Unavailable

◆ InspectorCapabilityRisk

enum class pulp::inspect::InspectorCapabilityRisk : std::uint8_t

strong

Enumerator
Observe
Sensitive
StreamingSensitive
ResourceConsuming
Control
HighRisk
Critical
Unavailable

◆ InspectorEvidence

enum class pulp::inspect::InspectorEvidence : std::uint8_t

strong

Enumerator
Response
Receipt
Artifact
Stream

◆ InspectorExecutor

enum class pulp::inspect::InspectorExecutor : std::uint8_t

strong

Enumerator
Protocol
HostMain
Background
RuntimeEvaluator
OfflineJob

◆ InspectorMethodKind

enum class pulp::inspect::InspectorMethodKind : std::uint8_t

strong

Enumerator
Request
Event

◆ InspectorProfile

enum class pulp::inspect::InspectorProfile : std::uint8_t

strong

Enumerator
Off
Observe
Develop
Custom

◆ InspectorSideEffect

enum class pulp::inspect::InspectorSideEffect : std::uint8_t

strong

Enumerator
None
Session
State
Capture
Trace
TestInput
Authoring
Telemetry
Evaluation
Render
Input
Reload
ArtifactRead

◆ InspectorTargetedEventResult

enum class pulp::inspect::InspectorTargetedEventResult

strong

Outcome of delivering one generation-scoped event to one authenticated transport client.

Telemetry brokers use the lossy outcomes as debt carried into their next delivered sample; reliable overflow closes the client.

Enumerator
Queued
QueuedAfterLossyEviction
DroppedLossy
ReliableOverflow
ClientNotFound
EventUnavailable
MessageTooLarge

◆ MidiTestInputKind

enum class pulp::inspect::MidiTestInputKind : std::uint8_t

strong

Enumerator
NoteOn
NoteOff

◆ TestInputReleaseReason

enum class pulp::inspect::TestInputReleaseReason : std::uint8_t

strong

Enumerator
ControllerReleased
ControllerExpired
ClientDisconnected
SessionTeardown

Function Documentation

◆ ack_in_file()

bool pulp::inspect::ack_in_file	(	const std::string &	path,
		std::string_view	id )

Ack id in the queue file at path, rewriting atomically.

Returns whether an id matched (false when absent/unreadable/no-match).

◆ ack_request()

std::optional< std::pair< std::string, bool > > pulp::inspect::ack_request	(	std::string_view	queue_json,
		std::string_view	id )

Mark the request whose id is id consumed in queue_json.

Returns the new document and whether an id matched (false: no such id, document unchanged). Returns nullopt when queue_json is a malformed queue document.

◆ append_request()

std::optional< std::string > pulp::inspect::append_request	(	std::string_view	queue_json,
		AgentRequest	request )

Append request to the queue encoded in queue_json, assigning a fresh id when request.id is empty (one greater than the largest numeric id present, starting at "1").

Returns the new queue document. Pure — no I/O. Returns nullopt when queue_json is a malformed queue document.

◆ apply_move_tweak_to_view()

bool pulp::inspect::apply_move_tweak_to_view	(	View &	view,
		std::string_view	property_path,
		const choc::value::Value &	value )

Move-tweak namespace bridge.

The move gesture emits layout.position / layout.left / layout.top tweaks — the same layout.* namespace the existing resize tweaks and the TS import-IR use, so the TS/React runtime path (applyTweaks -> setByDottedPath -> layout section -> setPosition/setTop/setLeft bridge calls) and lock-to-source Path A (lock_property_to_style_name strips layout. and finds position/top/left in its allow-list) consume them directly. The C++ JSON-import + codegen path, however, reads position from IRStyle.{position,top,left} (the style.* world), so a project that drives the native runtime apply path needs a tiny mapping from the layout.* tweak namespace onto the live View setters.

apply_move_tweak_to_view is that mapping: given a dotted move-tweak property path and its value, it writes the corresponding View input (set_position / set_left / set_top), so a move tweak round-trips on the C++/native path the same way it does in the TS world. Returns true if the path was a recognized move property and was applied. Accepts either the layout.* namespace (the move gesture's emission) or the bare leaf (position / left / top). Unknown paths return false without touching the view.

◆ canonicalize_control_json()

std::optional< std::string > pulp::inspect::canonicalize_control_json ( std::string_view json )

Canonicalizes an arbitrary JSON value by recursively sorting object keys.

Returns nullopt for malformed JSON or inputs exceeding the payload bound.

◆ capability_contract_id()

std::string_view pulp::inspect::capability_contract_id ( InspectorCapability capability )

◆ capability_from_contract_id()

std::optional< InspectorCapability > pulp::inspect::capability_from_contract_id ( std::string_view id )

◆ capability_from_id()

std::optional< InspectorCapability > pulp::inspect::capability_from_id ( std::string_view id )

◆ capability_id()

std::string_view pulp::inspect::capability_id ( InspectorCapability capability )

◆ capability_is_grantable()

bool pulp::inspect::capability_is_grantable ( InspectorCapability capability )

◆ capability_requires_controller_lease()

bool pulp::inspect::capability_requires_controller_lease ( InspectorCapability capability )

◆ capability_requires_publication_binding()

bool pulp::inspect::capability_requires_publication_binding ( InspectorCapability capability )

◆ capability_risk()

InspectorCapabilityRisk pulp::inspect::capability_risk ( InspectorCapability capability )

◆ capability_risk_id()

std::string_view pulp::inspect::capability_risk_id ( InspectorCapabilityRisk risk )

◆ compute_badge_placement()

BadgePlacement pulp::inspect::compute_badge_placement	(	float	sel_x,
		float	sel_y,
		float	sel_h,
		float	badge_w,
		float	badge_h,
		float	root_w,
		float	gap = 5.0f,
		float	top_margin = 0.0f )

Place a badge of size (badge_w × badge_h) for a selection whose top-left is at (sel_x, sel_y) with height sel_h.

Default position is ABOVE the selection (sel_y - gap - badge_h). When that would clip under the window top (badge top < top_margin), the badge flips to BELOW the selection (sel_y + sel_h + gap). The x is clamped so the badge never runs off the left (< 0) or right (> root_w - badge_w) edge. root_w <= 0 disables the right clamp.

Pure arithmetic so it is unit-testable headlessly.

◆ control_admission_request()

std::optional< ControlAdmissionRequest > pulp::inspect::control_admission_request ( const ControlRequestEnvelope & envelope )

Converts a strictly decoded wire request into the broker-owned admission request.

It verifies the canonical request hash before any authority lookup.

◆ control_admission_status_id()

std::string_view pulp::inspect::control_admission_status_id ( ControlAdmissionStatus status )

◆ control_artifact_deletion_reason_id()

std::string_view pulp::inspect::control_artifact_deletion_reason_id ( ControlArtifactDeletionReason reason )

◆ control_artifact_status_id()

std::string_view pulp::inspect::control_artifact_status_id ( ControlArtifactStatus status )

◆ control_consent_identity()

std::string pulp::inspect::control_consent_identity	(	std::string_view	manifest_digest,
		std::string_view	artifact_digest )

◆ control_denial_reason_id()

std::string_view pulp::inspect::control_denial_reason_id ( ControlDenialReason reason )

◆ control_endpoint_identity()

std::optional< ControlEndpointIdentity > pulp::inspect::control_endpoint_identity ( const std::filesystem::path & endpoint_path )

Capture a socket only when its parent is private and its path is an owner-owned 0600 local endpoint.

◆ control_envelope_allowed()

bool pulp::inspect::control_envelope_allowed	(	const ControlEnvelope &	envelope,
		ControlEnvelopeDirection	direction )

Direction is transport state, not payload authority.

Carriers call this after decoding and close on a role-incompatible frame.

◆ control_evidence_content_type()

std::string_view pulp::inspect::control_evidence_content_type ( ControlEvidenceKind kind )

◆ control_evidence_contract_matches()

bool pulp::inspect::control_evidence_contract_matches	(	ControlEvidenceKind	kind,
		std::string_view	content_type,
		ControlArtifactSensitivity	sensitivity,
		ControlArtifactRedactionState	redaction_state )

◆ control_grant_status_id()

std::string_view pulp::inspect::control_grant_status_id ( ControlGrantStatus status )

◆ control_host_tier_id()

std::string_view pulp::inspect::control_host_tier_id ( ControlHostTier tier )

◆ control_identity_status_id()

std::string_view pulp::inspect::control_identity_status_id ( ControlIdentityStatus status )

◆ control_manifest_digest()

std::string pulp::inspect::control_manifest_digest ( const ControlManifest & manifest )

◆ control_manifest_error_id()

std::string_view pulp::inspect::control_manifest_error_id ( ControlManifestError error )

◆ control_negotiation_status_id()

std::string_view pulp::inspect::control_negotiation_status_id ( ControlNegotiationStatus status )

◆ control_operation_registry()

std::span< const ControlOperationDescriptor > pulp::inspect::control_operation_registry ( )

◆ control_operation_store_status_id()

std::string_view pulp::inspect::control_operation_store_status_id ( ControlOperationStoreStatus status )

◆ control_peer_process_liveness()

ControlProcessLiveness pulp::inspect::control_peer_process_liveness ( const ControlPeerEvidence & evidence )

Conservatively reports whether the kernel process behind previously observed peer evidence is still live.

PID reuse remains live until the process-scoped reconnect lease expires; it can never inherit the principal.

◆ control_permission_terms()

std::span< const std::string_view > pulp::inspect::control_permission_terms ( )

◆ control_profile_from_id()

std::optional< ControlBuildProfile > pulp::inspect::control_profile_from_id ( std::string_view id )

◆ control_profile_id()

std::string_view pulp::inspect::control_profile_id ( ControlBuildProfile profile )

◆ control_receipt_state_id()

std::string_view pulp::inspect::control_receipt_state_id ( ControlReceiptState state )

◆ control_receipt_state_is_terminal()

bool pulp::inspect::control_receipt_state_is_terminal ( ControlReceiptState state )

◆ control_request_hash()

std::optional< std::string > pulp::inspect::control_request_hash ( const ControlRequestEnvelope & request )

Hashes the authority and operation binding plus canonical request parameters.

The transport request_id and deadline are deliberately not part of replay identity.

◆ control_result_code_id()

std::string_view pulp::inspect::control_result_code_id ( ControlResultCode code )

◆ control_retry_classification_id()

std::string_view pulp::inspect::control_retry_classification_id ( ControlRetryClassification retry )

◆ control_service_status_id()

std::string_view pulp::inspect::control_service_status_id ( ControlServiceStatus status )

◆ control_sidecar_directories()

std::vector< std::filesystem::path > pulp::inspect::control_sidecar_directories ( const std::filesystem::path & executable_directory )

Directories that may hold the control sidecars of an executable living in executable_directory (<name>.inspector-capabilities.json, <name>.

<format>.control-shipping.json, ...-report.json), in lookup order. A macOS bundle keeps them in Contents/Resources: Apple reserves Contents/MacOS for code, and a data file there makes the bundle fail an ordinary (non --deep) code signature. Bundles built before that layout kept them beside the executable, which is still listed second so they stay readable. Any other artifact keeps them beside its binary. (A framework's sidecars, in Versions/<v>/Resources, are build evidence that no reader resolves from an executable, so they are not covered here.) Pure path arithmetic; nothing is read from disk.

◆ control_sidecar_executable_directory()

std::filesystem::path pulp::inspect::control_sidecar_executable_directory ( const std::filesystem::path & sidecar_directory )

The directory of the executable a sidecar in sidecar_directory describes: <bundle>/Contents/MacOS for a macOS bundle's Contents/Resources, and the directory itself otherwise.

Pure path arithmetic; nothing is read from disk.

◆ control_timeline_admissible_writer_profile()

std::optional< std::string > pulp::inspect::control_timeline_admissible_writer_profile ( std::string_view requested )

noexcept

Returns the writer-profile name the broker admits for requested.

Returns nullopt for an unknown name and for trusted: the broker never selects the unquotaed authority on a caller's behalf and never escalates a caller into it. An empty request resolves to proposal, the least authority, rather than to whatever the host happens to hold.

◆ control_timeline_conflict_result_code()

ControlResultCode pulp::inspect::control_timeline_conflict_result_code ( pulp::timeline::ConflictCode conflict )

noexcept

Projects a session-side conflict onto the broker result code.

One-directional by construction: broker policy reads the authority verdict the session already reached and never re-decides it, so there is no second authority model to drift. CapabilityDenied is the CommandAuthority axis and lands on PolicyDenied.

◆ control_timeline_conflict_retry()

ControlRetryClassification pulp::inspect::control_timeline_conflict_retry ( pulp::timeline::ConflictCode conflict )

noexcept

Returns how a caller may retry a request refused with conflict.

◆ control_timeline_document_session_action_by_name()

std::optional< ControlTimelineDocumentSessionAction > pulp::inspect::control_timeline_document_session_action_by_name ( std::string_view name )

noexcept

Resolves an action from its public name, or nullopt for an unknown name.

◆ control_timeline_document_session_action_name()

std::string_view pulp::inspect::control_timeline_document_session_action_name ( ControlTimelineDocumentSessionAction action )

noexcept

Returns the stable public name of action, as the JSON schema spells it.

◆ control_trusted_host_inventory_status_id()

std::string_view pulp::inspect::control_trusted_host_inventory_status_id ( ControlTrustedHostInventoryStatus status )

◆ control_trusted_host_launch_status_id()

std::string_view pulp::inspect::control_trusted_host_launch_status_id ( ControlTrustedHostLaunchStatus status )

◆ control_ui_input_disposition()

std::string_view pulp::inspect::control_ui_input_disposition ( )

noexcept

Stable registry/documentation disposition for the UI-input contract.

◆ decode_control_envelope()

std::optional< ControlEnvelope > pulp::inspect::decode_control_envelope	(	std::string_view	json,
		ControlProtocolDiagnostics *	diagnostics = nullptr )

◆ decode_control_host_bootstrap()

std::optional< ControlHostBootstrapRecord > pulp::inspect::decode_control_host_bootstrap	(	std::span< const std::uint8_t >	bytes,
		std::chrono::system_clock::time_point	now = std::chrono::system_clock::now(),
		ControlHostBootstrapDiagnostics *	diagnostics = nullptr )

◆ decode_control_legacy_inspector_error()

std::optional< ControlLegacyInspectorError > pulp::inspect::decode_control_legacy_inspector_error ( std::string_view detail_json )

◆ decode_message()

bool pulp::inspect::decode_message	(	const std::string &	json,
		InspectorMessage &	out )

Parse a JSON string into a message. Returns false on parse failure.

◆ default_control_endpoint_path() [1/2]

std::filesystem::path pulp::inspect::default_control_endpoint_path ( )

Deterministic LocalSocket endpoint for the control broker.

◆ default_control_endpoint_path() [2/2]

std::filesystem::path pulp::inspect::default_control_endpoint_path ( const std::filesystem::path & runtime_root )

◆ default_control_runtime_directory() [1/2]

std::filesystem::path pulp::inspect::default_control_runtime_directory ( )

Deterministic owner-specific directory for the control carrier.

◆ default_control_runtime_directory() [2/2]

std::filesystem::path pulp::inspect::default_control_runtime_directory ( const std::filesystem::path & runtime_root )

Deterministic control directory below an explicitly supplied runtime root.

This overload is intended for embedding and deterministic tests; preparation still rejects relative or non-private paths.

◆ editor_url_env_override()

std::optional< std::string > pulp::inspect::editor_url_env_override ( )

Look up the environment override (PULP_INSPECTOR_EDITOR_URL).

Returns std::nullopt when unset or empty. Centralized here so tests and the protocol handler share one implementation.

◆ editor_url_source_name()

std::string_view pulp::inspect::editor_url_source_name ( EditorUrlSource source )

Stringify the source enum for protocol responses.

◆ effective_editor_url()

EffectiveEditorUrl pulp::inspect::effective_editor_url ( const InspectorConfig & config )

◆ encode_control_envelope()

std::string pulp::inspect::encode_control_envelope ( const ControlEnvelope & envelope )

Emits one deterministic JSON representation.

Returns an empty string if the in-memory envelope violates the same bounds enforced by the decoder.

◆ encode_control_host_bootstrap()

ControlHostBootstrapBytes pulp::inspect::encode_control_host_bootstrap ( const ControlHostBootstrapRecord & record )

◆ encode_control_legacy_inspector_error()

std::optional< std::string > pulp::inspect::encode_control_legacy_inspector_error ( const ControlLegacyInspectorError & error )

Encodes/decodes the strict compatibility object carried in a failed adapter receipt's detail_json.

Unknown structured error data is retained as its original JSON spelling. Malformed or out-of-bounds input fails closed.

◆ encode_message()

std::string pulp::inspect::encode_message ( const InspectorMessage & msg )

Serialize a message to a JSON string.

◆ enqueue_to_file()

std::optional< std::string > pulp::inspect::enqueue_to_file	(	const std::string &	path,
		AgentRequest	request )

Read + append + atomically rewrite the queue at path.

Creates the file when absent. Returns the assigned/kept id on success, nullopt on read/parse/write failure.

◆ evaluate_control_permission()

ControlPermissionDecision pulp::inspect::evaluate_control_permission ( const ControlPermissionInputs & inputs )

◆ evidence_id()

std::string_view pulp::inspect::evidence_id ( InspectorEvidence evidence )

◆ execute_control_instance_read()

ControlExecutionOutcome pulp::inspect::execute_control_instance_read	(	ControlBroker &	broker,
		const ControlAdmissionPlan &	plan,
		const ControlRequestEnvelope &	request,
		const ControlExecutionContext &	context )

Broker-local executor for dev.pulp.instance/read@1.

ControlService invokes this only after admission and receipt transition; checkpoint revalidation binds the result to the authenticated client, exact grant, and registration.

◆ executor_id()

std::string_view pulp::inspect::executor_id ( InspectorExecutor executor )

◆ find_inspector_method()

const InspectorMethodDescriptor * pulp::inspect::find_inspector_method ( std::string_view method )

◆ format_editor_url()

std::string pulp::inspect::format_editor_url	(	std::string_view	tmpl,
		std::string_view	path,
		int	line,
		std::optional< int >	col = std::nullopt )

Substitute {path}, {line}, and {col} in tmpl with the supplied values.

Tokens not present in the template are skipped. col is optional; when omitted, {col} substitutes as an empty string (the expected behavior for templates that omit the token entirely).

◆ generate_inspector_secret()

std::optional< std::vector< std::uint8_t > > pulp::inspect::generate_inspector_secret ( )

Generate a per-session 256-bit token or per-connection 256-bit nonce.

◆ inherited_control_host_bootstrap_handle()

ControlHostBootstrapHandle pulp::inspect::inherited_control_host_bootstrap_handle ( )

noexcept

Claims the private inherited standard-input handle.

Later calls in the same process return an invalid handle.

◆ inspector_capability_registry()

std::span< const InspectorCapabilityDescriptor > pulp::inspect::inspector_capability_registry ( )

◆ inspector_event_is_lossy()

bool pulp::inspect::inspector_event_is_lossy ( std::string_view method )

◆ inspector_method_registry()

std::span< const InspectorMethodDescriptor > pulp::inspect::inspector_method_registry ( )

◆ install_inspector_hooks()

void pulp::inspect::install_inspector_hooks ( InspectorOverlay & inspector )

Install the inspector into the View system's paint and input hooks.

Call this after creating the InspectorOverlay and setting g_active_inspector. Installs paint hook, key intercept, and mouse intercept via function pointers so pulp-view doesn't need to link pulp-inspect.

◆ installed_control_broker_executable()

std::filesystem::path pulp::inspect::installed_control_broker_executable ( const std::filesystem::path & client_executable )

Resolve the peer-verification anchor for a broker installed beside a CLI or MCP client.

Returns empty rather than trusting a path that cannot be canonicalized and verified.

◆ jump_to_source()

SourceJumpResult pulp::inspect::jump_to_source	(	const InspectorConfig &	config,
		const pulp::view::View *	view,
		bool	dry_run )

Convenience: resolve + launch in one call.

When dry_run is true, behaves exactly like resolve_source_jump() (no process spawned, launched stays false). When false and the resolve succeeded, the URL is launched and launched reflects the OS handler's result.

◆ launch_editor_url()

bool pulp::inspect::launch_editor_url	(	std::string_view	url,
		std::string *	error = nullptr )

Hand an editor URL to the OS handler.

Returns true if the launch command was dispatched successfully. macOS uses open, Linux uses xdg-open, Windows uses ShellExecute. An empty URL is a no-op that returns false. In CI/headless/test contexts this refuses to spawn and stores the reason in error when provided.

This is the side-effecting seam: callers that want a dry run (tests, the protocol dryRun param) should call resolve_source_jump() and skip this entirely.

◆ make_control_gpu_health_read_executor()

ControlOperationExecutor pulp::inspect::make_control_gpu_health_read_executor ( ControlGpuHealthReadSourceResolver resolve_source )

Creates the canonical dev.pulp.gpu/health.read@1 executor.

The operation only reads a provider-owned snapshot and preserves the admission plan's exact registration, instance, publication, deadline, grant, and receipt bindings. A host must not advertise the capability until it has a real product adapter backed by the required measurement and trace producers.

◆ make_control_offline_render_executor()

ControlOperationExecutor pulp::inspect::make_control_offline_render_executor	(	format::ProcessorFactory	factory,
		ControlOfflineRenderSourceResolver	resolve_source,
		ControlOfflineRenderClock	clock = {} )

Creates the canonical dev.pulp.render/offline@1 T0 executor.

The returned adapter performs no listening, registration, granting, or production activation. ControlService admits the operation and binds publish_artifact to the running receipt; this adapter only resolves trusted in-memory input, drives OfflineRenderHost, and publishes a float32 WAV.

◆ make_control_sample_region_edit_executor()

ControlOperationExecutor pulp::inspect::make_control_sample_region_edit_executor ( ControlSampleRegionTargetResolver )

◆ make_control_sample_region_read_executor()

ControlOperationExecutor pulp::inspect::make_control_sample_region_read_executor ( ControlSampleRegionTargetResolver )

◆ make_control_sequencer_state_edit_executor()

ControlOperationExecutor pulp::inspect::make_control_sequencer_state_edit_executor ( ControlSequencerStateTargetResolver resolve_target )

Implements dev.pulp.sequencer/state.edit@1.

Success means the typed edit was accepted by the lock-free command FIFO on the legal host thread. A full FIFO is a typed retryable ResourceExhausted refusal, never a silent drop and never a block on the audio thread. Engine application is asynchronous, so the receipt reports acceptance with the assigned client sequence rather than claiming the engine already folded the edit in.

◆ make_control_sequencer_state_read_executor()

ControlOperationExecutor pulp::inspect::make_control_sequencer_state_read_executor ( ControlSequencerStateTargetResolver resolve_target )

Implements dev.pulp.sequencer/state.read@1.

The published snapshot reference is copied out before the executor returns, so no caller can observe the triple buffer after a later publish has recycled it.

◆ make_control_sequencer_transport_read_executor()

ControlOperationExecutor pulp::inspect::make_control_sequencer_transport_read_executor ( ControlSequencerTransportTargetResolver resolve_target )

Implements dev.pulp.sequencer/transport.loop.read@1.

It reports the transport's accepted loop control state and current playing flag. A reset or failed prepare is unavailable even though an older playhead may have a nonzero sequence, and the operation never invents a loop that the transport has not accepted.

◆ make_control_sequencer_transport_write_executor()

ControlOperationExecutor pulp::inspect::make_control_sequencer_transport_write_executor ( ControlSequencerTransportTargetResolver resolve_target )

Implements dev.pulp.sequencer/transport.loop.write@1.

Endpoints arrive already snapped; the operation never snaps for the caller. The receipt carries the transport's acceptance, so every refusal the transport can return is mapped to its own message and the tick-domain collapsed-span refusal is distinguishable from all of them. Intended to be wrapped by ControlMainThreadExecutor; it refuses an off-main call whenever a real host dispatcher is installed.

◆ make_control_signal_graph_executor()

ControlOperationExecutor pulp::inspect::make_control_signal_graph_executor ( ControlSignalGraphAuthorityResolver resolve )

◆ make_control_standalone_host()

std::unique_ptr< format::StandaloneControlHost > pulp::inspect::make_control_standalone_host ( )

Creates the canonical broker-enrolled host bridge for an explicitly control-enabled Standalone executable.

A direct launch remains inert; only the broker's inherited, kernel-authenticated bootstrap can open the host.

◆ make_control_state_read_executor()

ControlOperationExecutor pulp::inspect::make_control_state_read_executor ( ControlStateReadSourceResolver resolve_source )

Creates the canonical dev.pulp.state/read@1 T0/T1 executor.

A T1 host gives this callback to ControlHostConnection; a T0 composition may inject it directly into ControlService. Exact selection remains in the admission plan, never in a filesystem path or legacy Inspector selector.

◆ make_control_state_write_executor()

ControlOperationExecutor pulp::inspect::make_control_state_write_executor ( ControlStateWriteTargetResolver resolve_target )

Implements dev.pulp.state/parameter-gesture@1.

Success means the exact begin->set->end bracket completed on the legal host thread; queued work is never reported as applied.

◆ make_control_timeline_document_session_executor()

ControlOperationExecutor pulp::inspect::make_control_timeline_document_session_executor ( ControlTimelineDocumentSessionSourceResolver resolve_source )

Creates the canonical dev.pulp.timeline/document-session@1 executor.

The operation preserves the admission plan's exact registration, instance, publication, deadline, grant, and receipt bindings, and validates every accepted payload against the operation's declared output schema before it publishes one.

◆ make_error()

InspectorMessage pulp::inspect::make_error	(	int64_t	id,
		std::string	error_message,
		std::string	error_code = "internal_error",
		std::string	error_data_json = "{}" )

◆ make_event()

InspectorMessage pulp::inspect::make_event	(	std::string	method,
		std::string	params_json = "{}" )

◆ make_inspector_auth_challenge()

std::optional< InspectorAuthChallenge > pulp::inspect::make_inspector_auth_challenge	(	std::string	session_id,
		std::string	instance_id,
		std::string	publication_id,
		std::string	protocol_version )

◆ make_inspector_auth_proof()

std::optional< std::string > pulp::inspect::make_inspector_auth_proof	(	std::span< const std::uint8_t >	token,
		const InspectorAuthChallenge &	challenge )

Construct the versioned HMAC proof used by installed clients.

The raw token is never placed in a protocol payload.

◆ make_inspector_server_auth_proof()

std::optional< std::string > pulp::inspect::make_inspector_server_auth_proof	(	std::span< const std::uint8_t >	token,
		const InspectorAuthChallenge &	challenge,
		std::string_view	client_proof )

Construct and verify the distinct server-side transcript proof returned after the client proof succeeds.

◆ make_installed_inspector_control_session_opener()

std::unique_ptr< InspectorControlSessionOpener > pulp::inspect::make_installed_inspector_control_session_opener	(	std::filesystem::path	client_executable,
		std::optional< std::string >	exact_instance_id = std::nullopt,
		std::string	legacy_profile = "develop" )

Build the installed-process opener used by CLI and MCP compatibility adapters.

The opener authenticates the sibling broker, enrolls a client, requires one unambiguous trace-capable live instance unless an exact instance is given, and asks the broker only for trace session control. The legacy profile argument is retained for source compatibility and is ignored. Broker consent remains the only authority source.

◆ make_request()

InspectorMessage pulp::inspect::make_request	(	int64_t	id,
		std::string	method,
		std::string	params_json = "{}" )

◆ make_response()

InspectorMessage pulp::inspect::make_response	(	int64_t	id,
		std::string	result_json )

◆ make_script_runtime_evaluator() [1/2]

std::unique_ptr< RuntimeEvaluator > pulp::inspect::make_script_runtime_evaluator ( ScriptedUiSessionVisitor visit_session )

◆ make_script_runtime_evaluator() [2/2]

std::unique_ptr< RuntimeEvaluator > pulp::inspect::make_script_runtime_evaluator ( view::ScriptInspectorBridge * bridge )

Construct the separately linked high-risk adapter for a live scripted UI.

◆ negotiate_control_protocol()

ControlNegotiationResult pulp::inspect::negotiate_control_protocol	(	const ControlNegotiationOffer &	local,
		const ControlNegotiationOffer &	peer,
		std::uint32_t	local_security_floor = kControlProtocolVersion )

Selects the highest common revision at or above local_security_floor.

◆ observe_control_peer()

std::optional< ControlPeerEvidence > pulp::inspect::observe_control_peer	(	const events::InterprocessConnection &	connection,
		ControlPeerRole	role )

Observe one connected OS-local peer through kernel credentials plus the platform process-generation and code-signing APIs.

Unsupported platforms, invalid signatures, dead processes, and non-local transports fail closed.

◆ observe_suspended_control_process()

std::optional< ControlPeerEvidence > pulp::inspect::observe_suspended_control_process	(	std::int64_t	process_id,
		ControlPeerRole	role )

Observe a newly spawned macOS process while it is still kernel-suspended.

Unsupported platforms and processes that cannot be bound to a live kernel generation and valid dynamic code object fail closed.

◆ parse_control_manifest()

std::optional< ControlManifest > pulp::inspect::parse_control_manifest	(	std::string_view	json,
		ControlManifestDiagnostics *	diagnostics = nullptr )

◆ pending_requests()

std::vector< AgentRequest > pulp::inspect::pending_requests ( std::string_view queue_json )

The not-yet-consumed requests in queue_json, in order.

A malformed document yields an empty list.

◆ pin_control_trusted_host_preparation_policy()

std::optional< ControlTrustedHostPreparationPolicy > pulp::inspect::pin_control_trusted_host_preparation_policy ( const ControlTrustedHostLaunchIntent & intent )

Pins the exact raw-host bytes, manifest, working directory, and adjacent native runtime closure selected by trusted broker policy.

◆ preflight_control_host() [1/2]

std::optional< VerifiedControlPeerIdentity > pulp::inspect::preflight_control_host	(	platform::ChildProcessInputChannel	channel,
		std::int64_t	expected_process_id,
		ControlPeerRole	role,
		const ControlPeerVerifier &	verifier,
		const ControlHostBootstrapProvider &	provide_bootstrap,
		std::chrono::milliseconds	timeout = std::chrono::seconds(3),
		ControlHostPreflightDiagnostics *	diagnostics = nullptr )

◆ preflight_control_host() [2/2]

std::optional< VerifiedControlPeerIdentity > pulp::inspect::preflight_control_host	(	platform::ChildProcessInputChannel	channel,
		std::int64_t	expected_process_id,
		ControlPeerRole	role,
		const ControlPeerVerifier &	verifier,
		ControlHostBootstrapBytes	bootstrap,
		std::chrono::milliseconds	timeout = std::chrono::seconds(3),
		ControlHostPreflightDiagnostics *	diagnostics = nullptr )

Challenge the process on a private inherited channel, verify the kernel- observed peer after its response, then release an already-minted bootstrap.

◆ prepare_control_runtime_directory()

bool pulp::inspect::prepare_control_runtime_directory ( const std::filesystem::path & runtime_directory )

Create or validate an absolute owner-only runtime directory.

Existing symlinks, non-directories, group/other access, and extended ACLs fail closed. Platforms without the verified local carrier return false.

◆ probe_control_broker()

ControlBrokerHealthProbeResult pulp::inspect::probe_control_broker	(	const ControlHealthProbeConfig &	config,
		std::chrono::milliseconds	response_timeout = std::chrono::seconds(3) )

Performs an observational local carrier probe without opening a control session.

Without an expected broker identity the strongest possible result is ReachableUnverified, and no health request is sent.

◆ profile_capabilities()

std::span< const InspectorCapability > pulp::inspect::profile_capabilities ( InspectorProfile profile )

◆ profile_from_id()

std::optional< InspectorProfile > pulp::inspect::profile_from_id ( std::string_view id )

◆ profile_id()

std::string_view pulp::inspect::profile_id ( InspectorProfile profile )

◆ queue_filename()

std::string_view pulp::inspect::queue_filename ( )

The canonical queue filename (beside .pulp-design-meta.json).

◆ queue_path()

std::string pulp::inspect::queue_path ( std::string_view project_dir )

The queue file path inside project_dir.

◆ read_control_host_bootstrap()

std::optional< ControlHostBootstrapRecord > pulp::inspect::read_control_host_bootstrap	(	ControlHostBootstrapHandle	handle,
		std::chrono::milliseconds	timeout = std::chrono::seconds(3),
		std::chrono::system_clock::time_point	now = std::chrono::system_clock::now(),
		ControlHostBootstrapDiagnostics *	diagnostics = nullptr )

Reads one bounded document to EOF, closes the inherited handle, and wipes the temporary encoded bytes on every path.

◆ read_pending_file()

std::vector< AgentRequest > pulp::inspect::read_pending_file ( const std::string & path )

The pending requests in the queue file at path (empty when the file is absent or unreadable).

◆ receive_control_host_preflight()

std::optional< ControlHostBootstrapRecord > pulp::inspect::receive_control_host_preflight	(	ControlHostBootstrapHandle	handle,
		std::chrono::milliseconds	timeout = std::chrono::seconds(3),
		std::optional< std::chrono::system_clock::time_point >	now = std::nullopt,
		ControlHostPreflightDiagnostics *	diagnostics = nullptr )

Complete the child side of one inherited preflight and decode its bootstrap.

The supplied handle is consumed and closed on every path.

◆ remove_stale_control_endpoint() [1/2]

bool pulp::inspect::remove_stale_control_endpoint ( const std::filesystem::path & endpoint_path )

Convenience for cleanup performed while the caller already holds the per-user daemon singleton and has established that the endpoint is stale.

◆ remove_stale_control_endpoint() [2/2]

bool pulp::inspect::remove_stale_control_endpoint	(	const std::filesystem::path &	endpoint_path,
		const ControlEndpointIdentity &	expected_identity )

Remove an endpoint only if its device and inode still match the identity captured before the caller's stale/liveness decision.

◆ request_control_inspector() [1/2]

InspectorClientResult pulp::inspect::request_control_inspector	(	InspectorControlSessionOpener &	opener,
		std::string	method,
		std::string	params_json = "{}",
		std::chrono::milliseconds	timeout = std::chrono::seconds(3) )

Execute one already-supported trace Inspector method through the canonical capability-control carrier.

Only Trace.startSession and Trace.stopSession are accepted. Progress is carrier-validated and deliberately not surfaced.

◆ request_control_inspector() [2/2]

InspectorClientResult pulp::inspect::request_control_inspector	(	std::string	method,
		std::string	params_json = "{}",
		std::chrono::milliseconds	timeout = std::chrono::seconds(3) )

Installed-process entry point for trace lifecycle adapters.

Production is default-denied until the broker installs an enrollment/session opener; callers never fall back to legacy discovery or a raw host/port connection.

◆ requests_from_json()

std::optional< std::vector< AgentRequest > > pulp::inspect::requests_from_json ( std::string_view queue_json )

Parse a queue document.

An empty/whitespace input is treated as an empty queue (returns an empty list, not nullopt) so a not-yet-created file reads cleanly. Returns nullopt only when the input is non-empty and not a valid queue document (bad JSON, or no "requests" array). Unknown members are ignored; a request missing "id" or "text" is skipped.

◆ requests_to_json()

std::string pulp::inspect::requests_to_json ( const std::vector< AgentRequest > & requests )

Serialize a request list to the canonical, stable JSON document.

◆ resolve_control_operation()

const ControlOperationDescriptor * pulp::inspect::resolve_control_operation	(	std::string_view	id,
		std::uint32_t	version )

◆ resolve_source_jump()

SourceJumpResult pulp::inspect::resolve_source_jump	(	const InspectorConfig &	config,
		const pulp::view::View *	view )

Resolve the source-jump target for view using config's editor URL template (with environment override applied).

Does NOT open the editor — pure computation, safe for tests. A null view, or a view without a recorded source_loc(), yields ok == false with a descriptive error.

◆ serialize_control_manifest()

std::string pulp::inspect::serialize_control_manifest ( const ControlManifest & manifest )

Emits the unique stable byte representation used for artifact digests.

◆ serialize_control_registry()

std::string pulp::inspect::serialize_control_registry ( )

Canonical projection of capability metadata and adapter operations.

◆ side_effect_id()

std::string_view pulp::inspect::side_effect_id ( InspectorSideEffect side_effect )

◆ uninstall_inspector_hooks()

void pulp::inspect::uninstall_inspector_hooks ( )

Tear down what install_inspector_hooks() set up: nulls g_active_inspector and releases all five View hook slots.

Call this before destroying the InspectorOverlay so a host that outlives its inspector cannot fire a hook bound to freed memory. Safe to call when no hooks were installed.

◆ valid_control_progress_transition()

bool pulp::inspect::valid_control_progress_transition	(	const ControlProgressEnvelope &	previous,
		const ControlProgressEnvelope &	next )

Checks that a later observation belongs to the same admitted operation and advances both sequence and completed work without changing the total.

◆ valid_control_receipt_transition()

bool pulp::inspect::valid_control_receipt_transition	(	ControlReceiptState	from,
		ControlReceiptState	to )

◆ validate_control_artifact_bytes()

ControlArtifactValidation pulp::inspect::validate_control_artifact_bytes	(	std::string_view	bytes,
		const ControlArtifactExpectation &	expectation )

Validates the immutable markers embedded in one exact executable snapshot.

Callers remain responsible for obtaining bytes through a race-safe snapshot.

◆ validate_control_json_schema()

bool pulp::inspect::validate_control_json_schema	(	std::string_view	instance_json,
		std::string_view	schema_json,
		ControlJsonSchemaDiagnostics *	diagnostics = nullptr )

Validates an untrusted JSON instance against the bounded JSON Schema subset used by Product A operation descriptors.

The schema is treated as trusted registry data, but unsupported or malformed schema keywords still fail closed so adding a contract keyword cannot silently weaken enforcement.

◆ validate_control_manifest()

bool pulp::inspect::validate_control_manifest	(	const ControlManifest &	manifest,
		std::string &	error )

◆ validate_control_manifest_detailed()

ControlManifestValidation pulp::inspect::validate_control_manifest_detailed ( const ControlManifest & manifest )

◆ validate_control_output_json_schema()

bool pulp::inspect::validate_control_output_json_schema	(	std::string_view	instance_json,
		std::string_view	schema_json,
		ControlJsonSchemaDiagnostics *	diagnostics = nullptr )

Validates an operation result using the larger, still-bounded result budget.

Request validation deliberately remains on the smaller control payload budget.

◆ validate_editor_url_template()

bool pulp::inspect::validate_editor_url_template	(	std::string_view	tmpl,
		std::string *	error_out = nullptr )

Validate a candidate editor URL template.

A template is valid iff it contains the {path} token — without a path the URI cannot point at the user's source file. Returns true on success; on failure, sets error_out to a human-readable message when non-null.

◆ verify_control_peer()

std::optional< VerifiedControlPeerIdentity > pulp::inspect::verify_control_peer	(	const events::InterprocessConnection &	connection,
		const ControlPeerExpectation &	expectation )

Mint a verified identity only when the live carrier evidence exactly matches the broker-owned expectation.

◆ verify_inspector_server_auth_proof()

bool pulp::inspect::verify_inspector_server_auth_proof	(	std::span< const std::uint8_t >	token,
		const InspectorAuthChallenge &	challenge,
		std::string_view	client_proof,
		std::string_view	server_proof )

Variable Documentation

◆ g_active_inspector

InspectorOverlay* pulp::inspect::g_active_inspector = nullptr

inline

Global inspector instance for the current window.

Set by the host when creating the inspector. The platform WindowHost checks this to intercept key/mouse events before normal dispatch. Thread-safe: only accessed on the UI thread.

◆ inspector_nonce_size

std::size_t pulp::inspect::inspector_nonce_size = 32

inlineconstexpr

◆ inspector_token_size

std::size_t pulp::inspect::inspector_token_size = 32

inlineconstexpr

◆ kControlAuthorityBindingVersion

std::uint32_t pulp::inspect::kControlAuthorityBindingVersion = 1

inlineconstexpr

◆ kControlCaptureMaximumBytes

std::size_t pulp::inspect::kControlCaptureMaximumBytes = 16u * 1024u * 1024u

inlineconstexpr

◆ kControlDevelopmentMaximumTextBytes

std::size_t pulp::inspect::kControlDevelopmentMaximumTextBytes = 4096

inlineconstexpr

◆ kControlEnvelopeSchema

std::string_view pulp::inspect::kControlEnvelopeSchema = "dev.pulp.control/envelope@1"

inlineconstexpr

◆ kControlHostBootstrapMaximumBytes

std::size_t pulp::inspect::kControlHostBootstrapMaximumBytes = 16u * 1024u

inlineconstexpr

◆ kControlHostBootstrapSchema

std::string_view pulp::inspect::kControlHostBootstrapSchema = "dev.pulp.control/host-bootstrap@1"

inlineconstexpr

◆ kControlHostBootstrapVersion

std::uint32_t pulp::inspect::kControlHostBootstrapVersion = 1

inlineconstexpr

Transport primitives for a record already minted by broker-owned enrollment.

They do not authenticate, register, admit, or launch a host. The record format is not authenticated and its fields are never a trust root. The production broker daemon does not issue these records and remains denied.

◆ kControlHostMaximumArtifactPublicationBytes

std::size_t pulp::inspect::kControlHostMaximumArtifactPublicationBytes = 1u * 1024u * 1024u

inlineconstexpr

◆ kControlHostMaximumArtifactPublications

std::size_t pulp::inspect::kControlHostMaximumArtifactPublications = 1

inlineconstexpr

◆ kControlHostPreflightMaximumBootstrapBase64Bytes

std::size_t pulp::inspect::kControlHostPreflightMaximumBootstrapBase64Bytes = 24u * 1024u

inlineconstexpr

◆ kControlLegacyInspectorJsonEncoding

std::string_view pulp::inspect::kControlLegacyInspectorJsonEncoding = "legacy-inspector-json-v1"

inlineconstexpr

◆ kControlManifestSchemaId

std::string_view pulp::inspect::kControlManifestSchemaId = "dev.pulp.control/artifact-manifest@1"

inlineconstexpr

◆ kControlManifestSchemaVersion

std::uint32_t pulp::inspect::kControlManifestSchemaVersion = 1

inlineconstexpr

◆ kControlMaximumArtifactChunkBase64Bytes

std::size_t pulp::inspect::kControlMaximumArtifactChunkBase64Bytes

inlineconstexpr

Initial value:

=

((kControlMaximumArtifactReadBytes + 2u) / 3u) * 4u

pulp::inspect::kControlMaximumArtifactReadBytes

constexpr std::size_t kControlMaximumArtifactReadBytes

Definition control_protocol.hpp:33

◆ kControlMaximumArtifactContentTypeBytes

std::size_t pulp::inspect::kControlMaximumArtifactContentTypeBytes = 256

inlineconstexpr

◆ kControlMaximumArtifactMetadataFieldBytes

std::size_t pulp::inspect::kControlMaximumArtifactMetadataFieldBytes = 512

inlineconstexpr

◆ kControlMaximumArtifactReadBytes

std::size_t pulp::inspect::kControlMaximumArtifactReadBytes = 1024u * 1024u

inlineconstexpr

◆ kControlMaximumConnectionAdmissions

std::size_t pulp::inspect::kControlMaximumConnectionAdmissions = 1024

inlineconstexpr

◆ kControlMaximumConnectionAdmissionTtl

auto pulp::inspect::kControlMaximumConnectionAdmissionTtl = std::chrono::seconds(30)

inlineconstexpr

◆ kControlMaximumEnvelopeBytes

std::size_t pulp::inspect::kControlMaximumEnvelopeBytes = 2u * 1024u * 1024u

inlineconstexpr

◆ kControlMaximumErrorCodeBytes

std::size_t pulp::inspect::kControlMaximumErrorCodeBytes = 128

inlineconstexpr

◆ kControlMaximumHostEnrollments

std::size_t pulp::inspect::kControlMaximumHostEnrollments = 1024

inlineconstexpr

◆ kControlMaximumHostEnrollmentTtl

auto pulp::inspect::kControlMaximumHostEnrollmentTtl = std::chrono::seconds(30)

inlineconstexpr

◆ kControlMaximumRequestPayloadBytes

std::size_t pulp::inspect::kControlMaximumRequestPayloadBytes = 512u * 1024u

inlineconstexpr

◆ kControlMaximumResultDetailBytes

std::size_t pulp::inspect::kControlMaximumResultDetailBytes = 1600u * 1024u

inlineconstexpr

◆ kControlMaximumSdkVersionBytes

std::size_t pulp::inspect::kControlMaximumSdkVersionBytes = 128

inlineconstexpr

◆ kControlMaximumStatusIdBytes

std::size_t pulp::inspect::kControlMaximumStatusIdBytes = 64

inlineconstexpr

◆ kControlOperationReceiptSchemaId

std::string_view pulp::inspect::kControlOperationReceiptSchemaId

inlineconstexpr

Initial value:

=

"dev.pulp.control/operation-receipt@1"

◆ kControlOperationReceiptSchemaVersion

std::uint32_t pulp::inspect::kControlOperationReceiptSchemaVersion = 1

inlineconstexpr

◆ kControlProtocolVersion

std::uint32_t pulp::inspect::kControlProtocolVersion = 1

inlineconstexpr

◆ kControlReceiptMaximumArtifactIdBytes

std::size_t pulp::inspect::kControlReceiptMaximumArtifactIdBytes = 128

inlineconstexpr

◆ kControlReceiptMaximumArtifactMediaTypeBytes

std::size_t pulp::inspect::kControlReceiptMaximumArtifactMediaTypeBytes = 128

inlineconstexpr

◆ kControlReceiptMaximumArtifacts

std::size_t pulp::inspect::kControlReceiptMaximumArtifacts = 64

inlineconstexpr

◆ kControlReceiptMaximumCancellationReasonBytes

std::size_t pulp::inspect::kControlReceiptMaximumCancellationReasonBytes = 1024

inlineconstexpr

◆ kControlReceiptMaximumEvidenceIdBytes

std::size_t pulp::inspect::kControlReceiptMaximumEvidenceIdBytes = 128

inlineconstexpr

◆ kControlReceiptMaximumEvidenceIds

std::size_t pulp::inspect::kControlReceiptMaximumEvidenceIds = 64

inlineconstexpr

◆ kControlReceiptMaximumExplanationBytes

std::size_t pulp::inspect::kControlReceiptMaximumExplanationBytes = 1024

inlineconstexpr

◆ kControlReceiptMaximumOperationIdBytes

std::size_t pulp::inspect::kControlReceiptMaximumOperationIdBytes = 256

inlineconstexpr

◆ kControlReceiptMaximumRequestIdBytes

std::size_t pulp::inspect::kControlReceiptMaximumRequestIdBytes = 128

inlineconstexpr

Receipt normalization and wire encoding use these same field boundaries.

◆ kControlRegistryDigest

std::string_view pulp::inspect::kControlRegistryDigest = "d98850681408945533dff4b647ddf0309f500cdbafc13f4af983ba4674410e8e"

inlineconstexpr

◆ kControlRuntimeEvalMaximumResultBytes

std::size_t pulp::inspect::kControlRuntimeEvalMaximumResultBytes = 256u * 1024u

inlineconstexpr

◆ kControlUiMaximumCoordinate

double pulp::inspect::kControlUiMaximumCoordinate = 1'000'000.0

inlineconstexpr

◆ kControlUiMaximumKeyBytes

std::size_t pulp::inspect::kControlUiMaximumKeyBytes = 64

inlineconstexpr

◆ kControlUiMaximumTargetBytes

std::size_t pulp::inspect::kControlUiMaximumTargetBytes = 256

inlineconstexpr

◆ kControlUiMaximumTextBytes

std::size_t pulp::inspect::kControlUiMaximumTextBytes = 4096

inlineconstexpr

◆ kControlUiMaximumViewGenerationBytes

std::size_t pulp::inspect::kControlUiMaximumViewGenerationBytes = 128

inlineconstexpr

◆ kInspectorExtendedMessageBytes

std::size_t pulp::inspect::kInspectorExtendedMessageBytes

inlineconstexpr

Initial value:

=

16u * 1024u * 1024u

Bounded transfer ceiling used by clients and by hosts that expose image capture.

Ordinary inspector servers may retain their smaller 1 MiB default.

◆ kRuntimeEvalDeadline

std::chrono::milliseconds pulp::inspect::kRuntimeEvalDeadline {2000}

inlineconstexpr

◆ kRuntimeEvalMaxCodeBytes

std::size_t pulp::inspect::kRuntimeEvalMaxCodeBytes = 64u * 1024u

inlineconstexpr

◆ kRuntimeEvalMaxResponseBytes

std::size_t pulp::inspect::kRuntimeEvalMaxResponseBytes = 1024u * 1024u

inlineconstexpr

◆ kRuntimeEvalMaxResultBytes

std::size_t pulp::inspect::kRuntimeEvalMaxResultBytes = 1024u * 1024u

inlineconstexpr

Pulp 1.88.0 Cross-platform audio plugin framework

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ ControlAdmissionConsumer

◆ ControlArtifactPublisher

◆ ControlClientNegotiationResult

◆ ControlClientReceiptResult

◆ ControlConnectionPrincipal

◆ ControlDeferredCompletion

◆ ControlEnvelopePayload

◆ ControlExecutionGuard

◆ ControlGpuHealthReadSourceResolver

◆ ControlHostBootstrapHandle

◆ ControlHostBootstrapProvider

◆ ControlMotionTargetResolver

◆ ControlOfflineRenderClock

◆ ControlOfflineRenderSourceResolver

◆ ControlOperationExecutor

◆ ControlProgressReporter

◆ ControlRuntimeEvalRedactor

◆ ControlSampleRegionTargetResolver

◆ ControlSequencerStateTargetResolver

◆ ControlSequencerTransportTargetResolver

◆ ControlSignalGraphAuthorityResolver

◆ ControlStateReadSourceResolver

◆ ControlStateWriteTargetResolver

◆ ControlTimelineDocumentSessionSourceResolver

◆ ControlUiAuthorityResolver

◆ ControlUiInput

◆ InspectorEventRetirementSink

◆ InspectorEventSink

◆ InspectorTargetedEventSink

◆ ScriptedUiSessionVisitor

Enumeration Type Documentation

◆ ControlAdmissionStatus

◆ ControlArtifactDeletionReason

◆ ControlArtifactDeletionState

◆ ControlArtifactRedactionState

◆ ControlArtifactSensitivity

◆ ControlArtifactStatus

◆ ControlBrokerHealthProbeStatus

◆ ControlBuildProfile

◆ ControlConnectionAdmissionStatus

◆ ControlConsentAuthority

◆ ControlConsentPromptResult

◆ ControlDenialReason

◆ ControlDiagnosticSeverity

◆ ControlDurableClientLifetime

◆ ControlEnvelopeDirection

◆ ControlEvidenceKind

◆ ControlExecutionCheckpoint

◆ ControlGrantSelectorKind

◆ ControlGrantStatus

◆ ControlHostBootstrapStatus

◆ ControlHostEnrollmentStatus

◆ ControlHostPreflightStatus

◆ ControlHostTier

◆ ControlIdentityStatus

◆ ControlJsonSchemaError

◆ ControllerLeaseResult

◆ ControlManifestError

◆ ControlNegotiationStatus

◆ ControlOperationAuthorizationKind

◆ ControlOperationStoreStatus

◆ ControlPeerRole

◆ ControlProcessLiveness

◆ ControlProtocolError

◆ ControlReceiptState

◆ ControlResultCode

◆ ControlRetryClassification

◆ ControlSecurityOutcome

◆ ControlServiceStatus

◆ ControlTelemetrySensitivity

◆ ControlTimelineDocumentSessionAction

◆ ControlTrustedHostInventoryStatus

◆ ControlTrustedHostLaunchStatus