Expand description
§PocketStation
Capture one desktop application in Rust, keep its audio identifiable, and use the same capture for processing, delivery, and recording. Add a microphone only when the application needs a second independent source.
desktop application ─┐
system audio ────────┼─ Session ─┬─ your Rust code
microphone ──────────┤ ├─ Operator or Connector
application PCM ─────┘ └─ one recording file per stemPocketStation is for applications that need direct control of desktop audio: voice systems, meeting tools, broadcast workflows, transcription, monitoring, and local media automation. It is not an AI model, conferencing service, or general codec framework.
§Capture a running application
You need Rust 1.95 or newer and one supported desktop application producing audio.
cargo add pocketstation@1.1.13use pocketstation::{Session, Source};
let session = Session::new();
session
.capture(Source::application("Spotify"))?
.send(session.polled_audio()?)?;
let mut running = session.start()?;Replace Spotify with the exact display name or application identifier of a
running application. PocketStation rejects an ambiguous match instead of
silently choosing a process. The declaration is the same on macOS, Windows,
and Linux; operating-system permissions and native build dependencies differ.
This example opens no microphone and writes no file. The quickstart includes application discovery, frame polling, a 10-second media deadline, optional microphone and recording arguments, and joined shutdown.
Run it from this repository:
cargo run --release --example quickstart --lockedThe command lists running applications and asks which one to capture. It stops
after receiving audio from every requested source. Add --microphone or
--record recordings only when you want those features.
§Keep sources separate
Application, system, microphone, and application-owned PCM enter a Session as
different stems. Every frame identifies its source, stream, stem, sequence,
timestamp, clock, and continuity state. Sending two stems to the same provider
does not mix them or erase where they came from.
use pocketstation::{Session, Source};
let session = Session::builder().recording_root("recordings").build();
let application = session.capture(Source::application("Zoom"))?;
let microphone = session.capture(Source::microphone_default())?;
application.record("application")?;
microphone.record("microphone")?;Recording starts with the Session and finishes during Session shutdown. The final recording outcome reports which stems completed or failed. PocketStation does not present a partial recording as a successful one.
§Use one capture for several jobs
The package includes built-in echo cancellation through
Session::echo_cancel. The native engine is excluded from default builds. Enable the aec Cargo
feature explicitly; aec_available() reports whether it is included. Callers select the microphone and playback reference;
Session registers the processor and owns its worker. Same-clock PCM integration
is tested; physical double-talk and device-clock adaptation are not yet
qualified. See echo cancellation
for the supported inputs and current limitations.
A stem can feed several destinations at once:
- application code that reads frames;
- an
Operatorthat turns audio into another signal, such as a transcript; - a
Connectorthat sends audio to an external service; - another
OperatororEndpointwith its own delivery settings; - multistem recording.
Each destination has its own queue and failure outcome. Slow model or network work runs outside the capture callback, so it does not become part of the operating-system audio callback.
Use capture and route audio to add a second source or destination. Use record and observe to inspect delivery, discontinuities, and final outcomes.
§Send audio to your own service
A Connector sends Session audio to an API, socket, file, or provider. For a
destination that needs one function, PocketStation owns the worker and calls
your function away from realtime capture:
use pocketstation::connector::Connector;
use pocketstation::{Session, Source};
let session = Session::new();
let application = session.capture(Source::application("Spotify"))?;
let destination = session.destination(Connector::from_audio_fn(|frame| {
publish(frame.samples())
})?)?;
application.send(destination)?;Implement AudioConnector when one provider connection needs start, send,
and stop. Use the driver API only for distributable packages that need typed
configuration, named inputs, service status, or provider-specific observations.
The Connector guide explains both forms.
Use an Operator, not a Connector, when audio becomes a transcript, event, or
new audio stream. Use a Source when an external system sends media into the
Session. The extension guide explains custom
Sources, Operators, Endpoints, native libraries, and managed processes.
§Write PCM your application already owns
Generated speech, call audio, and decoded network media can enter through
audio_input() and use the same routing and recording APIs as captured audio.
The input reports Full, Closed, Cancelled, and invalid-buffer outcomes;
it does not hide backpressure in an unbounded application queue.
See write application-owned audio for the preallocated writer API and selective removal of output that should no longer be delivered.
§Understand delivery and failure
PocketStation prepares every Source, Operator, Connector, Endpoint, and recording destination before it opens the Session start gate. A setup failure rolls back prepared resources. Stopping a running Session joins its workers and returns one result that includes component and recording failures.
Use SessionStartCancellation::observed() when a caller needs to inspect native
startup while Session::start_cancellable is still running. The token exposes
64 current-call slots and the first 128 completed native calls without audio samples or
source identifiers. Cancellation is cooperative: it cannot interrupt an
in-flight operating-system call. SessionStartError::rollback_failures_total()
reports cleanup failures so callers can keep resources reserved when cleanup is
uncertain. See capture and route for the
observation limits and recovery behavior.
Realtime callbacks and realtime processing are checked to remain:
allocation-free · lock-free · blocking-free · async-free · log-free · panic-freeQueues and pools have configured capacities. When a queue fills, its delivery policy decides whether a frame is rejected or dropped, and observations report the event. Read delivery and failure before choosing settings for voice, recording, or model work.
§Handle permissions and source changes
Your application owns consent UI and source selection. PocketStation reports permission state, source loss, source generation changes, discontinuities, queue pressure, and recording results.
Check permission without prompting when the platform supports it. Store a discovered source only for its reported persistence scope. If the application or microphone disappears, stop the Session, discover again, confirm the new selection, and start another Session. PocketStation does not switch to a different source without the application deciding to do so.
The platform operations guide lists permission states, source persistence, recovery steps, and native prerequisites.
§Platform support
| Platform | Available sources | Published evidence |
|---|---|---|
| macOS | system, application, and microphone | physical system, application, and microphone capture; 10 ms application and microphone capture; Relay, Chromium, and multistem recording |
| Windows | system, application, and microphone | automated Windows 11 ARM64 VM selection and 10 ms capture; physical-device and latency qualification remain separate |
| Linux | PipeWire application/system and ALSA microphone | automated Ubuntu selection and 10 ms capture; physical-device qualification remains separate |
These records establish only the named environment and test. They do not establish identical device behavior, WAN/TURN performance, or one latency number for every computer.
Native prerequisites:
-
macOS: Xcode command-line tools;
-
Windows: MSVC Rust toolchain and Windows SDK;
-
Debian or Ubuntu:
sudo apt install build-essential cmake pkg-config \ libasound2-dev libpipewire-0.3-dev
Disable native capture when a tool only needs PocketStation types or docs:
pocketstation = { version = "1.1.14", default-features = false }§Continue from the task you have
| Task | Guide |
|---|---|
| Run the complete first capture | Rust quickstart |
| Capture and route application or microphone audio | Capture and route |
| Write generated or received PCM | Application audio |
| Record stems and inspect delivery | Record and observe |
| Send audio to an external service | Connectors |
| Add a Source, Operator, Endpoint, library, or process | Extensions |
| Understand Session start and shutdown | Session lifecycle |
| Understand signals, identity, and time | Signals and streams |
| Read events, metrics, outcomes, and errors | Events and errors |
| Find a public Rust type | API map or docs.rs |
| Prepare or troubleshoot a host | Platform support and troubleshooting |
| Check an upgrade | Compatibility and release notes |
§Verify a local change
cargo fmt --all -- --check
cargo clippy --all-targets --all-features --locked -- -D warnings
cargo test --all-targets --all-features --locked
cargo build --release --example quickstart --locked
bash scripts/check_protocol.shThese commands verify source and component behavior. Physical devices, cross-network delivery, and platform performance require separately recorded tests in those environments.
§License
PocketStation is available under the MIT or Apache-2.0 license.
Re-exports§
pub use crate::graph::AsyncNode;pub use crate::graph::AsyncNodeFuture;pub use crate::graph::AsyncOperatorFactory;pub use crate::graph::AsyncOperatorManifest;pub use crate::graph::AsyncOperatorManifestError;pub use crate::graph::AsyncOperatorPrepareContext;pub use crate::graph::AudioCaps;pub use crate::graph::BackpressurePolicy;pub use crate::graph::BinaryFormat;pub use crate::graph::ChannelLayout;pub use crate::graph::ClockDomain;pub use crate::graph::Codec;pub use crate::graph::ConfigError;pub use crate::graph::CopyPolicy;pub use crate::graph::DeliveryPolicy;pub use crate::graph::DeliverySemantics;pub use crate::graph::EventFormat;pub use crate::graph::ExecutionPartition;pub use crate::graph::ExecutionSafety;pub use crate::graph::LossPolicy;pub use crate::graph::MediaCaps;pub use crate::graph::MediaKind;pub use crate::graph::Multiplicity;pub use crate::graph::NodeConfig as OperatorConfiguration;pub use crate::graph::NodeDefinition;pub use crate::graph::NodeDescriptor;pub use crate::graph::NodeError;pub use crate::graph::NodeTypeId;pub use crate::graph::OperatorCancellationPolicy;pub use crate::graph::OperatorDeadlinePolicy;pub use crate::graph::OperatorFailurePolicy;pub use crate::graph::OperatorId;pub use crate::graph::OperatorOutputRolePolicy;pub use crate::graph::OperatorPermissionPolicy;pub use crate::graph::PortDirection;pub use crate::graph::PortPrepareContext;pub use crate::graph::PortSpec;pub use crate::graph::RouteObservability;pub use crate::graph::RouteSettings;pub use crate::graph::SchemaRef;pub use crate::graph::SemanticRole;pub use crate::graph::SignalClass;pub use crate::graph::SignalContinuityError;pub use crate::graph::SignalContinuityObservation;pub use crate::graph::SignalContinuityTracker;pub use crate::graph::SignalDerivation;pub use crate::graph::SignalDerivationError;pub use crate::graph::SignalEnvelope;pub use crate::graph::SignalEnvelopeError;pub use crate::graph::SignalId;pub use crate::graph::SignalLineage;pub use crate::graph::SignalLineageError;pub use crate::graph::SignalPayload;pub use crate::graph::SignalSpec;pub use crate::graph::SignalSpecError;pub use crate::graph::SignalTiming;pub use crate::graph::SignalTimingError;pub use crate::graph::TextFormat;
Modules§
- connector
- graph
- Stable signal, port, capability, partition, and extension APIs.
- native_
extension - timing
- Timing primitives owned by the PocketStation runtime.
Structs§
- Application
Process Set - A frozen, canonical selection; native opening must admit every member.
- Async
Operator Observations - Audio
Buffer Handle - Audio
Buffer Pool - Audio
Frame - Audio
History - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Read recent independently routed audio while its Session runs.
- Audio
History Config - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Limits shared by all stems in one history. Oldest buffers are evicted first. PCM bytes and buffer count are separate limits; endpoint queues are separate.
- Audio
History Observations - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
- Audio
Input - Feeds audio already owned by the embedding application into a Session.
- Audio
Input Buffer - Audio
Input Config - Audio
Input Observations - Audio
Input Write Error - Audio
Input Writer - Audio
Output Write Error - Audio
Processing - The actual input consumed to produce an audio frame.
- Capture
Authorization Snapshot - Point-in-time authorization evidence for opening one exact capture source.
- Capture
Delivery - Callback delivery endpoints transferred to a prepared native backend.
- Capture
Native Format - Exact native PCM format accepted by the operating-system capture stream.
- Capture
Observation Handle - Capture
Observations - Capture
Open Cancellation - Cooperative cancellation of a control-thread capture open.
- Capture
Permission Lifecycle - Control-plane owner for one source’s observed authorization epoch.
- Capture
Permission Transition - One authoritative authorization-state transition observed by the host.
- Capture
Processing Observation Handle - Read-only processing observations for one opened stream. Reads belong on control threads, never native audio callbacks.
- Capture
Processing Observations - Processing facts reported by the backend for one opened capture stream.
- Capture
Processing Reporter - Backend-owned writer for stream processing facts.
- Capture
Runtime Failure - Capture
Source - Captured
Frame Observation Handle - Captured
Frame Sender - Single-producer endpoint passed into a platform capture callback.
- Captured
Frame Stream Stats - Clock
Domain Id - Connection
Spec - The single Session connection declaration used for every stream origin and every operator/endpoint destination.
- Connector
Id - Derived
Stream Handle - Device
Id - Echo
Audio Input - A Session-owned audio source selected for echo processing.
- Echo
Cancellation Observations - Local processing observations, readable after the Session stops.
- Echo
Cancelled Audio - Processed audio and retained observations from one echo-cancellation instance.
- Echo
Input Processing - What is known about echo processing upstream of an input.
- Edge
Observations - Endpoint
Audio Frame - Read-only audio frame delivered to an external endpoint.
- Endpoint
Audio Receiver - Exclusive consumer for one bounded realtime-audio endpoint edge.
- Endpoint
Cancellation Outcome - Endpoint
Configuration - Endpoint
Descriptor - Endpoint
Driver Finalization - Endpoint
Driver Observations - Endpoint
Failure - Endpoint
Group Id - Explicit Session-scoped grouping key for endpoints that share one lifecycle.
- Endpoint
Handle - Endpoint
Id - Endpoint
Port Input - Endpoint
Prepare Context - Endpoint
Route Context - Typed Session route identity supplied to every endpoint input.
- Endpoint
Signal Receiver - Exclusive consumer for one bounded asynchronous signal endpoint edge.
- Endpoint
Start Gate - Read-only one-way start barrier shared by endpoint drivers in one startup.
- Frame
Lineage - Local
Source Provider - Native
AecRequest - Explicit request to pair microphone processing with one playback device.
- Native
AecRoute - Backend-observed configuration of one opened native microphone route.
- Native
AecRoute Handle - Immutable route metadata and allocation-free, lock-free validity observation.
- Native
AecRoute Reporter - Backend-owned revocation of facts for exactly one opened capture.
- Native
Call Observations - Bounded, independently coherent call records, rather than a global instant.
- Native
Call Span - One native-call fact in the process monotonic nanosecond domain.
- Native
Playback Reference - Explicit permission to use one playback device’s output mix as a native reference. No additional application or output recording is created by this declaration.
- Observed
Process Instance - A process identity observed before declaration, including its start time.
- Operator
- Operator
Input Handle - Operator
Instance Handle - Operator
Instance Id - Operator
Instance Spec - Output
Generation - Keeps replaceable output attached to the operation that produced it.
- Output
Generation Id - Core assigns no user, turn, model, or conversation meaning to this ID.
- PcmSource
- Low-level PCM source ownership for integrations that separately retain the Session handles and producer writer.
- Permission
Epoch - Plan
Source Input Observations - Playback
Reference - Explicit permission to use an already-declared stream as an echo reference. This never opens, records or sends another application’s audio.
- Polled
Audio Batch Lease - Polled
Audio Frame - Polled
Audio Observations - Polled
Audio Receipt - Process
Id - Recorded
Audio - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. An inspected finalized recording. This owns the bounded original manifest; every extraction rechecks it and the selected WAV on the same open handle. The caller owns authorization for this directory and schedules blocking I/O.
- Recorded
Stem - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Exact persisted identity and format of one independently recorded stem.
- Recording
Clip - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. A bounded float32 WAV clip with its original source and timing observations.
- Recording
Clip Window - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. A half-open interval in the recording’s Session clock, in nanoseconds. Any external audio, text, telemetry or control detector may supply this interval.
- Recording
Discontinuity - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
- RouteId
- Running
Session - Sample
Spec - Session
- Session
Audio Reentry Metrics - Exact boundedness and lifecycle accounting for one operator PCM output re-entering the Session audio lane.
- Session
Builder - Setup-time configuration for the public Rust Session.
- Session
Cancel Result - Session
Compile Diagnostic - Stable, language-neutral location facts for one Session compilation error.
- Session
Control Failure - Typed control-plane failure without exposing an implementation error type.
- Session
Derived Route Metrics - Session
Event - Event emitted by the session lifecycle authority.
- Session
Event Queue Observations - Point-in-time observations for a session’s bounded control-event queue.
- Session
External Source Metrics - Session
Id - Session
Metrics Snapshot - Point-in-time observations for the current Session.
- Session
Operator Input Metrics - Session
Operator Metrics - Session
Recording Observations - Session
Recording Outcome - Session
Recording Receipt - Session
Recording Stem Outcome - Session
Route Drop Observations - Explicit numerator, denominator, interval, and typed reasons for one route.
- Session
Route Latency Observations - Common-clock source timestamp to route-receive latency in nanoseconds.
- Session
Route Metrics - Session
Sidecar Metrics - Exact bounded-queue and process-lifecycle accounting for one Session-owned language-neutral sidecar.
- Session
Source Activity Evaluation - Session
Source Activity Observations - Raw process-clock activity observed after a built-in Source frame leaves the capture queue and reaches the canonical Session runtime.
- Session
Source Activity Policy - Caller-owned deadlines for evaluating Source delivery activity.
- Session
Source Metrics - Session
Source Native Format Observation - Native acquisition format observed when one built-in Source opened.
- Session
Source Processing Observations - Processing observations bound to the currently attached physical capture. Replacement or detach invalidates observations from the previous open.
- Session
Source Replacement - Result of one explicit built-in microphone replacement inside a running Session. The logical stem and every compiled route remain unchanged while physical source lineage advances.
- Session
Source Replacement Observations - Control-path accounting for explicit physical-source replacement.
- Session
Source Signal Evaluation - Session
Source Signal Observations - Latest delivered PCM-window measurements for one built-in Source.
- Session
Source Signal Policy - Caller-owned thresholds for interpreting one Source signal observation.
- Session
Start Cancellation - Thread-safe cancellation request for a Session that has not reached
Runningyet. - Session
Start Error - Stable façade error for Session startup.
- Session
Stop Outcome - Session
Stop Result - Session
Timeline Origin - One Session-owned anchor in PocketStation’s monotonic nanosecond clock.
- Session
Trace - Session
Trace Record - Session
Trace Recorder - Session
Trace Recorder Outcome - Session
Trace Terminal - Session
Trace Validation - Shared
Audio Buffer Handle - Shared
Audio Frame - Sidecar
Deadlines - Sidecar
Host Snapshot - Sidecar
Message - Sidecar
Process Spec - Sidecar
Protocol Limits - Source
Cancellation - Source
Configuration - Source
Emission - Source
Generation - Source
Id - Source
Instance Handle - Source
Instance Id - Source
Instance Spec - Source
Manifest - Source
Output Handle - Source
Output Identity - Source
Output Spec - Source
Prepare Context - Source
Runtime Event Observation Handle - Source
Runtime Event Observations - Source
Runtime Event Sender - Source
Runtime Observations - Source
Session Context - Source
Type Id - Stable
Source Id - Stem
Handle - StemId
- Stream
- Typed Rust declaration façade compiled into stable dynamic signal, schema, port, and RouteSettings. This wrapper carries no frames and is not a generic runtime queue.
- Stream
Id - Typed
Operator
Enums§
- Application
Policy Observation - Application
Selector - Audio
Buffer Write Error - Audio
Frame Build Error - Audio
Frame Duration - Fixed audio cadence used by capture and Session routing.
- Audio
History Declaration Error - Audio
History Error - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
- Audio
History State - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
- Audio
Input Buffer Acquire Error - Audio
Input Buffer Error - Audio
Input Config Error - Audio
Input Error - Audio
Input Write Error Kind - Audio
Output Write Error Kind - Capture
Capability State - Capture
Error - Capture
Mode - Capture
Open Failure - Failed or cancelled acquisition, retaining a separate cleanup failure.
- Capture
Open Outcome - Capture
Runtime Failure Class - Capture
Sample Representation - Native PCM representation opened by a capture backend before conversion to
PocketStation’s canonical interleaved
f32signal. - Capture
Scope - Capture
Session Grant - Captured
Frame Delivery - Connection
Target - Stable destination of a declared Session connection.
- Device
Selector - Echo
Cancellation State - Processor lifecycle; Processing does not assert acoustic convergence.
- Endpoint
Failure Retryability - Machine-readable recovery classification retained in Session outcomes.
- Endpoint
Failure Stage - Endpoint
Input Origin - Provenance of one endpoint input, independent of its physical receiver.
- Endpoint
Preparation Group - Factory-owned decision for batching endpoint inputs into one lifecycle.
- Endpoint
Receiver - Endpoint
Shutdown Mode - Session shutdown intent delivered to an active endpoint.
- Frame
Lineage Build Error - Input
Device Selector - Native
Call Operation - Static control-call names; values never contain source or device identity.
- Output
Cancel Result - Output
Generation Error - Permission
Observation - Platform
- Polled
Audio Poll Error - Polled
Audio Poll Error Code - Stable language-neutral code for bounded polled-audio status.
- Process
SetError - Control-path failures for declaring and admitting an exact process set.
- Process
Tree Scope - Recording
Clip Error - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Typed failure of recording inspection or bounded clip extraction.
- Recording
Discontinuity Kind - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings.
- Route
Latency Measurement - Identifies the timestamps used to calculate route latency.
- Sample
Format - Selector
Persistence Scope - Session
Cancel Disposition - Session
Component Id - Stable identity of the component that produced a session control failure.
- Session
Declaration Error Code - Stable language-neutral code for a Session declaration failure.
- Session
Endpoint Error - Session
Error - Session
Event Kind - Payload of one authoritative session event.
- Session
Event Receive - Result of non-blocking event polling.
- Session
Lifecycle State - Public lifecycle states emitted by a running session.
- Session
Operator Error - Session
Recording Error Code - Stable language-neutral code for a recording failure.
- Session
Recording State - Session
Route Latency Unit - Session
Route Observation Interval - Interval covered by monotonic route counters.
- Session
Runtime Error - Session
Runtime Error Code - Stable language-neutral code for a running-Session binding failure.
- Session
Sidecar Error - Session
Source Activity Policy Error - Session
Source Activity State - Session
Source Error - Session
Source Replacement Error - Session
Source Signal Policy Error - Session
Source Signal State - Session
Start Error Code - Stable language-neutral code for Session startup.
- Session
Start Error Kind - Session
Stop Code - Stable language-neutral status for an idempotent Session stop.
- Session
Stop Disposition - Session
Stop Failure Code - Stable language-neutral cause retained by a failed Session stop.
- Session
Terminal State - Final state carried by the terminal session event.
- Session
Trace Record Kind - Session
Trace Recorder Finish Error - Session
Trace Recorder Start Error - Session
Trace Validation Error - Sidecar
Host Error - Sidecar
Message Kind - Sidecar
State - Source
- Source
Driver Error - Source
Identity Strength - Source
Kind - Source
Lifecycle Event Kind - Source
Manifest Error - Source
Query - Source
Recovery Requirement - Source
Registration Error - Source
Runtime Event - Source
Runtime Event Delivery - Source
State - Source
Type IdError - Stream
Origin - Stable origin of a declared Session stream.
- Typed
Stream Error
Constants§
- DEFAULT_
MULTISTEM_ RECORDING_ GROUP_ ID - MAX_
APPLICATION_ PROCESS_ SET_ MEMBERS - Maximum number of independently observed processes in one exact capture.
- MAX_
RECORDING_ CLIP_ BYTES - Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Source-aware replay and bounded context windows over finalized recordings. Maximum encoded WAV bytes returned by one clip request (32 MiB).
- NATIVE_
CALL_ COMPLETED_ CAPACITY - First completed calls retained by one observed cancellation token.
- NATIVE_
CALL_ CURRENT_ CAPACITY - Maximum independently observed capture opens on one cancellation token.
- PCM_
SOURCE_ TYPE_ ID - Stable runtime identity of the underlying PCM source implementation.
- SESSION_
RECORDING_ MANIFEST_ FILE_ NAME - SESSION_
RECORDING_ MANIFEST_ SCHEMA_ VERSION
Traits§
- Active
Capture Backend - Native capture resources owned for exactly one active capture.
- Callback
Capture Backend - Platform-neutral prepare/open API for callback-oriented capture.
- Endpoint
Driver Factory - Prepared
Capture Backend - Backend state that has passed validation but has not started delivery.
- Prepared
Endpoint Driver - Prepared endpoint resources that have not started consuming their edge.
- Running
Endpoint Driver - Active endpoint resources owned until finalization.
- Source
Driver - Source
Factory - Source
Provider - Stream
Signal - Compile-time marker supplied by an SDK or external package.
Functions§
- aec_
available - Whether this build includes the AEC engine. This does not qualify a device route.
- application_
capture_ available - Reports whether this host exposes the native application-capture facility.
- capture_
processing_ observations - Creates an initially unknown observation pair for one capture open.
- discover_
process_ instances - Discovers process instances with usable original start observations.
- discover_
sources - microphone_
permission_ observation - Reads the current microphone authorization state without prompting.
- native_
aec_ route - Creates backend-owned configuration evidence for one opened capture.
- polled_
audio_ poll_ error_ code - resolve_
query - session_
declaration_ error_ code - session_
recording_ outcome_ error_ code - session_
start_ failure_ code