use serde::{Deserialize, Serialize};
use crate::{CoreError, Digest};
pub const MAX_AUDIO_SAMPLE_RATE_HZ: u32 = 192_000;
pub const MAX_AUDIO_FRAMES: u32 = 5_760_000;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AudioPrefillPlanV1 {
pub projector: Digest,
pub projector_sample_rate_hz: u32,
pub maximum_frames: u32,
}
impl AudioPrefillPlanV1 {
pub fn digest(&self) -> Result<Digest, CoreError> {
if self.projector_sample_rate_hz == 0
|| self.projector_sample_rate_hz > MAX_AUDIO_SAMPLE_RATE_HZ
{
return Err(CoreError::invalid(
"audio prefill plan",
"projector sample rate is outside the supported bound",
));
}
if self.maximum_frames == 0 || self.maximum_frames > MAX_AUDIO_FRAMES {
return Err(CoreError::invalid(
"audio prefill plan",
"maximum frames is outside the supported bound",
));
}
Digest::of_serializable("audio-prefill-plan-v1", self)
}
pub fn validate_samples(&self, samples: &[f32]) -> Result<u32, CoreError> {
self.digest()?;
let frames = u32::try_from(samples.len())
.map_err(|_| CoreError::invalid("audio prefill samples", "frame count exceeds u32"))?;
if frames == 0 || frames > self.maximum_frames {
return Err(CoreError::invalid(
"audio prefill samples",
"frame count is outside the declared bound",
));
}
if samples
.iter()
.any(|sample| !sample.is_finite() || !(-1.0..=1.0).contains(sample))
{
return Err(CoreError::invalid(
"audio prefill samples",
"samples must be finite normalized mono PCM values",
));
}
Ok(frames)
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AudioPrefillReceiptV1 {
pub plan: Digest,
pub audio: Digest,
pub frames: u32,
pub admitted_tokens: u32,
pub initial_position: u64,
pub final_position: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub prefill_receipt: Option<Digest>,
}
impl AudioPrefillReceiptV1 {
pub fn digest_for(&self, plan: &AudioPrefillPlanV1) -> Result<Digest, CoreError> {
let plan_digest = plan.digest()?;
if self.plan != plan_digest {
return Err(CoreError::invalid(
"audio prefill receipt",
"receipt plan does not match the supplied plan",
));
}
if self.frames == 0 || self.frames > plan.maximum_frames {
return Err(CoreError::invalid(
"audio prefill receipt",
"receipt frame count is outside the declared bound",
));
}
let expected_position = self
.initial_position
.checked_add(u64::from(self.admitted_tokens))
.ok_or_else(|| CoreError::invalid("audio prefill receipt", "position overflowed"))?;
if self.final_position != expected_position {
return Err(CoreError::invalid(
"audio prefill receipt",
"final position does not match admitted tokens",
));
}
Digest::of_serializable("audio-prefill-receipt-v1", self)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn plan() -> AudioPrefillPlanV1 {
AudioPrefillPlanV1 {
projector: Digest::of_bytes("test-projector", b"qwen3-asr"),
projector_sample_rate_hz: 16_000,
maximum_frames: 16_000,
}
}
#[test]
fn normalized_mono_samples_are_bounded_without_retention() {
let plan = plan();
assert_eq!(plan.validate_samples(&[-1.0, 0.0, 1.0]).unwrap(), 3);
assert!(plan.validate_samples(&[]).is_err());
assert!(plan.validate_samples(&[f32::NAN]).is_err());
assert!(plan.validate_samples(&[1.01]).is_err());
}
#[test]
fn receipt_binds_plan_and_exact_causal_progression() {
let plan = plan();
let receipt = AudioPrefillReceiptV1 {
plan: plan.digest().unwrap(),
audio: Digest::of_bytes("private-audio", b"identity-only"),
frames: 8_000,
admitted_tokens: 12,
initial_position: 4,
final_position: 16,
prefill_receipt: None,
};
assert!(receipt.digest_for(&plan).is_ok());
let mut malformed = receipt;
malformed.final_position = 15;
assert!(malformed.digest_for(&plan).is_err());
}
}