Skip to main content

qualia_core_db/bundle/stream/http/
mixed.rs

1//! HTTP mixed-plan driver. C5 `HttpProvider` plus C4 `Schedule::next`.
2//! Headers are the adapter. Bodies stay exact representation bytes.
3//! JSON is not an application object. HTTP status is not a grant.
4//! Incomplete mandatory is not 200/206. TLS/Web PKI is not PQ publisher authority.
5use super::{
6    FallbackPolicy, HttpObject, HttpProvider, InclusiveRange, ProviderError, ServeOptions, Served,
7    Validator,
8};
9use crate::audio::qac::{QacStorageOptions, QacStorageView};
10use crate::bundle::stream::formats::{
11    emf_present_id, p64_present_id, qac_present_id, AuthenticatedRange, EmfStreamView,
12    P64StreamView, Q42AuthenticatedRangeSource, QacStreamView,
13};
14use crate::bundle::stream::plan::{
15    evaluate, EntryFamily, Inventory, Obligation, PlanError, PrincipalSelection, Readiness,
16    RecordUnit, Region, Schedule, ScheduledUnit, WorkClass, MAX_PLAN_ENTRIES, MAX_SCHEDULE_ITEMS,
17};
18use crate::bundle::stream::policy::{LocalEffectControl, LocalWholeSourceGrant};
19use crate::bundle::stream::proof::{
20    OutboardNode, SpanLimits, VerifiedLeafSpan, LEAF_BYTES, MAX_SIBLINGS,
21};
22use crate::bundle::stream::proof::verify_leaf_span;
23use crate::bundle::stream::selection::SelectedPlainEntry;
24use crate::crypto::network::authority::PinAuthority;
25use crate::net::peer::replication::qbdl::provider::{OutboardCatalog, OutboardLimits};
26use crate::net::peer::runtime::ReservationLedger;
27use crate::net::qdnf::types::StrongDigest;
28use crate::q42::field_envelope::{Family, Limits, StructuralView};
29
30/// One selected publication entry bound to its HTTP provider.
31pub struct BoundHttpEntry<'src, 'sel, 'nodes, 'meta> {
32    pub entry_id: u32,
33    pub provider: HttpProvider<'src, 'sel, 'nodes, 'meta>,
34}
35
36/// One representation actually written into the caller `out` buffer.
37#[derive(Clone, Copy)]
38pub struct ServedObject {
39    pub entry_id: u32,
40    pub family: EntryFamily,
41    pub status: u16,
42    pub body_off: usize,
43    pub body_len: usize,
44    pub total: u64,
45    pub etag: [u8; 98],
46    pub etag_len: usize,
47}
48
49/// Counts from one `serve_scheduled` walk. No `Debug` — tests `match` errors.
50pub struct HttpMuxReport {
51    pub transferred: u16,
52    pub control: u16,
53    pub delayed_deferred: u16,
54    pub cancelled_skipped: u16,
55    pub shared_reused: u16,
56    pub order: [Option<EntryFamily>; MAX_SCHEDULE_ITEMS],
57    pub order_len: u16,
58    pub objects: [Option<ServedObject>; MAX_SCHEDULE_ITEMS],
59    pub objects_len: u16,
60}
61
62/// Compiled fair schedule plus the readiness gate for this HTTP walk.
63pub struct HttpMux {
64    schedule: Schedule,
65    blocked: Option<ProviderError>,
66    shared_reused: u16,
67    cancelled_skipped: u16,
68    deferred_pending: u16,
69    deferred_ids: [u32; MAX_PLAN_ENTRIES],
70    deferred_len: usize,
71}
72
73fn map_plan(e: PlanError) -> ProviderError {
74    match e {
75        PlanError::Capacity | PlanError::Limit => ProviderError::Capacity,
76        PlanError::DuplicateId | PlanError::Identity | PlanError::Cycle | PlanError::Graph => {
77            ProviderError::Identity
78        }
79        PlanError::Field | PlanError::Unsupported => ProviderError::Unsupported,
80        PlanError::Refused => ProviderError::Policy,
81    }
82}
83
84fn deferred_family(family: Option<EntryFamily>) -> bool {
85    matches!(family, Some(EntryFamily::M64 | EntryFamily::P64))
86}
87
88/// Exact selected-entry bytes. Bounds refuse; this is not a grant.
89pub fn entry_slice<'a>(
90    source: &'a [u8],
91    selected: SelectedPlainEntry<'_>,
92) -> Result<&'a [u8], ProviderError> {
93    let start = usize::try_from(selected.offset()).map_err(|_| ProviderError::Bounds)?;
94    let len = usize::try_from(selected.logical_length()).map_err(|_| ProviderError::Bounds)?;
95    let end = start.checked_add(len).ok_or(ProviderError::Bounds)?;
96    if end > source.len() {
97        return Err(ProviderError::Identity);
98    }
99    Ok(&source[start..end])
100}
101
102fn whole_span<'a>(
103    selected: SelectedPlainEntry<'a>,
104    bytes: &'a [u8],
105    siblings: &'a mut [StrongDigest],
106) -> Result<VerifiedLeafSpan<'a>, ProviderError> {
107    if selected.logical_length() != bytes.len() as u64 {
108        return Err(ProviderError::Identity);
109    }
110    let spec = selected.tree_spec().map_err(|_| ProviderError::Identity)?;
111    verify_leaf_span(
112        &spec,
113        selected.root(),
114        0,
115        bytes,
116        &[&[0]],
117        siblings,
118        SpanLimits {
119            max_leaves: 1,
120            max_encoded_bytes: LEAF_BYTES as usize,
121        },
122    )
123    .map_err(|_| ProviderError::Proof)
124}
125
126/// Family tags `Qac` / `Emf` only after whole-entry admit. A blob is not those families.
127pub fn entry_admits_family(
128    source: &[u8],
129    selected: SelectedPlainEntry<'_>,
130    family: EntryFamily,
131) -> bool {
132    let Ok(bytes) = entry_slice(source, selected) else {
133        return false;
134    };
135    if selected.logical_length() != bytes.len() as u64 {
136        return false;
137    }
138    match family {
139        EntryFamily::Qac => {
140            let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
141            if let Ok(span) = whole_span(selected, bytes, &mut siblings) {
142                if let Ok(range) = AuthenticatedRange::new(selected, &span, 0, bytes.len()) {
143                    if let Ok(view) = QacStreamView::admit(range, QacStorageOptions::default()) {
144                        return qac_present_id(selected.entry_id(), &view).is_some();
145                    }
146                }
147            }
148            QacStorageView::open(bytes, QacStorageOptions::default()).is_ok()
149        }
150        EntryFamily::Emf => {
151            let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
152            if let Ok(span) = whole_span(selected, bytes, &mut siblings) {
153                if let Ok(range) = AuthenticatedRange::new(selected, &span, 0, bytes.len()) {
154                    if let Ok(view) = EmfStreamView::admit(range, Limits::default()) {
155                        return emf_present_id(selected.entry_id(), &view).is_some();
156                    }
157                }
158            }
159            StructuralView::open(bytes, Family::EmfV4Candidate, Limits::default()).is_ok()
160        }
161        EntryFamily::Q42 => {
162            let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
163            let Ok(span) = whole_span(selected, bytes, &mut siblings) else {
164                return false;
165            };
166            let Ok(range) = AuthenticatedRange::new(selected, &span, 0, bytes.len()) else {
167                return false;
168            };
169            Q42AuthenticatedRangeSource::new(selected, &[range], bytes.len() as u64, 1).is_ok()
170        }
171        EntryFamily::Opaque => false,
172        EntryFamily::P64 => {
173            let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
174            if let Ok(span) = whole_span(selected, bytes, &mut siblings) {
175                if let Ok(range) = AuthenticatedRange::new(selected, &span, 0, bytes.len()) {
176                    if let Ok(view) = P64StreamView::admit(range) {
177                        return p64_present_id(selected.entry_id(), &view).is_some();
178                    }
179                }
180            }
181            false
182        }
183        EntryFamily::TenD | EntryFamily::M64 => true,
184    }
185}
186
187/// Bind C5 provider to one selected entry's outboard. Does not wrap `HttpRangeSource`.
188pub fn bind_http_entry<'src, 'sel, 'nodes, 'meta>(
189    source: &'src [u8],
190    selected: SelectedPlainEntry<'sel>,
191    nodes: &'nodes [OutboardNode],
192    root: StrongDigest,
193    descriptor: &'meta [u8],
194    entry_page: &'meta [u8],
195) -> Result<BoundHttpEntry<'src, 'sel, 'nodes, 'meta>, ProviderError> {
196    let spec = selected.tree_spec().map_err(|_| ProviderError::Identity)?;
197    let catalog = OutboardCatalog::new(
198        selected,
199        spec,
200        root,
201        nodes,
202        OutboardLimits {
203            max_nodes: nodes.len(),
204            max_bytes: nodes.len() * core::mem::size_of::<OutboardNode>(),
205        },
206    )?;
207    Ok(BoundHttpEntry {
208        entry_id: selected.entry_id(),
209        provider: HttpProvider::bind(source, catalog, descriptor, entry_page)?,
210    })
211}
212
213impl HttpMux {
214    pub fn compile(
215        inventory: &Inventory<'_>,
216        selections: &[PrincipalSelection<'_>],
217        present: &[u32],
218    ) -> Result<Self, ProviderError> {
219        let (blocked, shared_reused, deferred_ids, deferred_len) =
220            inspect(inventory, selections, present);
221        let schedule = Schedule::compile(inventory, selections, present).map_err(map_plan)?;
222        Ok(Self {
223            schedule,
224            blocked,
225            shared_reused,
226            cancelled_skipped: 0,
227            deferred_pending: deferred_len as u16,
228            deferred_ids,
229            deferred_len,
230        })
231    }
232
233    pub fn next_unit(&mut self) -> Option<ScheduledUnit> {
234        self.schedule.next()
235    }
236
237    pub fn acknowledge(&mut self, unit: ScheduledUnit) -> Result<(), ProviderError> {
238        self.schedule
239            .acknowledge_complete(unit.principal(), unit.entry_id(), unit.unit().leaf())
240            .map_err(map_plan)
241    }
242
243    pub fn acknowledge_complete(
244        &mut self,
245        principal: u64,
246        entry_id: Option<u32>,
247        leaf: u64,
248    ) -> Result<(), ProviderError> {
249        self.schedule
250            .acknowledge_complete(principal, entry_id, leaf)
251            .map_err(map_plan)
252    }
253
254    pub fn cancel(&mut self, entry_id: u32, region: Option<Region>) -> usize {
255        let n = self.schedule.cancel(entry_id, region);
256        if n > 0 {
257            self.cancelled_skipped = self.cancelled_skipped.saturating_add(n as u16);
258            if self.is_deferred_id(entry_id) {
259                self.deferred_pending = self.deferred_pending.saturating_sub(1);
260            }
261        }
262        n
263    }
264
265    pub fn occupancy_retained(&self, principal: u64, entry_id: Option<u32>, leaf: u64) -> bool {
266        self.schedule.occupancy_retained(principal, entry_id, leaf)
267    }
268
269    pub fn push_control(&mut self, principal: u64, unit: RecordUnit) -> Result<(), ProviderError> {
270        self.schedule.push_control(principal, unit).map_err(map_plan)
271    }
272
273    pub fn is_charged(&self, entry_id: u32) -> bool {
274        self.schedule.is_charged(self.schedule.candidate(), entry_id)
275    }
276
277    pub const fn cancelled_skipped(&self) -> u16 {
278        self.cancelled_skipped
279    }
280
281    pub const fn shared_reused(&self) -> u16 {
282        self.shared_reused
283    }
284
285    pub const fn len(&self) -> usize {
286        self.schedule.len()
287    }
288
289    fn is_deferred_id(&self, entry_id: u32) -> bool {
290        self.deferred_ids[..self.deferred_len]
291            .iter()
292            .any(|id| *id == entry_id)
293    }
294}
295
296/// Drive `next` until empty. Control acknowledges with no HTTP body.
297/// `HttpProvider` always reserves: skip a second serve of the same entry identity.
298/// One grant scopes the walk (`LocalWholeSourceGrant` is one-shot).
299pub fn serve_scheduled(
300    mux: &mut HttpMux,
301    entries: &[BoundHttpEntry<'_, '_, '_, '_>],
302    grant: &mut LocalWholeSourceGrant<'_, '_>,
303    pins: &PinAuthority,
304    clock: impl Fn() -> u64,
305    ledger: &mut ReservationLedger,
306    out: &mut [u8],
307) -> Result<HttpMuxReport, ProviderError> {
308    if let Some(e) = mux.blocked {
309        return Err(e);
310    }
311    match grant.accept_local_scoped(pins, clock, |authority| {
312        Ok(drive_scheduled(mux, entries, authority, ledger, out))
313    }) {
314        Ok(inner) => inner,
315        Err(_) => Err(ProviderError::Policy),
316    }
317}
318
319fn drive_scheduled(
320    mux: &mut HttpMux,
321    entries: &[BoundHttpEntry<'_, '_, '_, '_>],
322    authority: &mut LocalEffectControl<'_, '_>,
323    ledger: &mut ReservationLedger,
324    out: &mut [u8],
325) -> Result<HttpMuxReport, ProviderError> {
326    let mut report = HttpMuxReport {
327        transferred: 0,
328        control: 0,
329        delayed_deferred: 0,
330        cancelled_skipped: mux.cancelled_skipped,
331        shared_reused: mux.shared_reused,
332        order: [None; MAX_SCHEDULE_ITEMS],
333        order_len: 0,
334        objects: [None; MAX_SCHEDULE_ITEMS],
335        objects_len: 0,
336    };
337    let mut sent = [None; MAX_SCHEDULE_ITEMS];
338    let mut sent_len = 0usize;
339    let mut cursor = 0usize;
340    while let Some(unit) = mux.next_unit() {
341        push_order(&mut report, unit.family());
342        if unit.entry_id().is_none() || unit.class() == WorkClass::Control {
343            if mux.deferred_pending > 0 {
344                report.delayed_deferred = report.delayed_deferred.saturating_add(1);
345            }
346            mux.acknowledge(unit)?;
347            report.control = report.control.saturating_add(1);
348            continue;
349        }
350        let id = match unit.entry_id() {
351            Some(id) => id,
352            None => return Err(ProviderError::Identity),
353        };
354        let family = match unit.family() {
355            Some(f) => f,
356            None => return Err(ProviderError::Identity),
357        };
358        let leaf = unit.unit().leaf();
359        if sent[..sent_len].iter().any(|slot| *slot == Some((id, leaf))) {
360            report.shared_reused = report.shared_reused.saturating_add(1);
361            mux.acknowledge(unit)?;
362            continue;
363        }
364        let idx = match entries.iter().position(|e| e.entry_id == id) {
365            Some(i) => i,
366            None => return Err(ProviderError::Identity),
367        };
368        let deferred = deferred_family(unit.family());
369        if !deferred && mux.deferred_pending > 0 {
370            report.delayed_deferred = report.delayed_deferred.saturating_add(1);
371        }
372        let provider = &entries[idx].provider;
373        let total = provider.selected().logical_length();
374        let range = InclusiveRange::from_start_length(0, total)?;
375        let mut etag = [0u8; 98];
376        let etag_len = provider.representation_etag(&mut etag)?;
377        let served: Served = provider.serve(
378            HttpObject::Representation,
379            Some(range),
380            Some(&etag[..etag_len]),
381            Validator {
382                etag: Some(&etag[..etag_len]),
383                last_modified: None,
384            },
385            ServeOptions {
386                fallback: FallbackPolicy::FORBIDDEN,
387                verified_peer: true,
388            },
389            authority,
390            ledger,
391            &mut out[cursor..],
392        )?;
393        if served.status != 200 && served.status != 206 {
394            return Err(ProviderError::Unsatisfiable);
395        }
396        let object = ServedObject {
397            entry_id: id,
398            family,
399            status: served.status,
400            body_off: cursor,
401            body_len: served.body_len,
402            total: served.total,
403            etag: served.headers.etag,
404            etag_len: served.headers.etag_len,
405        };
406        cursor = cursor
407            .checked_add(served.body_len)
408            .ok_or(ProviderError::Capacity)?;
409        if report.objects_len as usize >= MAX_SCHEDULE_ITEMS {
410            return Err(ProviderError::Capacity);
411        }
412        report.objects[report.objects_len as usize] = Some(object);
413        report.objects_len = report.objects_len.saturating_add(1);
414        if sent_len < MAX_SCHEDULE_ITEMS {
415            sent[sent_len] = Some((id, leaf));
416            sent_len += 1;
417        }
418        if deferred {
419            mux.deferred_pending = mux.deferred_pending.saturating_sub(1);
420        }
421        mux.acknowledge(unit)?;
422        report.transferred = report.transferred.saturating_add(1);
423    }
424    Ok(report)
425}
426
427fn push_order(report: &mut HttpMuxReport, family: Option<EntryFamily>) {
428    let i = report.order_len as usize;
429    if i < MAX_SCHEDULE_ITEMS {
430        report.order[i] = family;
431        report.order_len = report.order_len.saturating_add(1);
432    }
433}
434
435fn inspect(
436    inventory: &Inventory<'_>,
437    selections: &[PrincipalSelection<'_>],
438    present: &[u32],
439) -> (
440    Option<ProviderError>,
441    u16,
442    [u32; MAX_PLAN_ENTRIES],
443    usize,
444) {
445    let mut blocked = None;
446    let mut cover = [0u8; MAX_PLAN_ENTRIES];
447    for sel in selections {
448        let mut seen = [false; MAX_PLAN_ENTRIES];
449        for intent in sel.request().intents() {
450            match evaluate(
451                inventory,
452                intent.entry_id(),
453                Some(intent.family()),
454                present,
455            ) {
456                Readiness::Refused | Readiness::Incomplete { .. } => {
457                    blocked = Some(ProviderError::Policy);
458                }
459                Readiness::Ready | Readiness::Opaque => {}
460            }
461            walk_ready(
462                inventory,
463                intent.entry_id(),
464                present,
465                &mut seen,
466                &mut cover,
467            );
468        }
469    }
470    let mut shared = 0u16;
471    for c in cover {
472        if c > 1 {
473            shared = shared.saturating_add(u16::from(c - 1));
474        }
475    }
476    let mut deferred_ids = [0u32; MAX_PLAN_ENTRIES];
477    let mut deferred_len = 0usize;
478    for (i, entry) in inventory.entries().iter().enumerate() {
479        if cover[i] == 0 || !deferred_family(Some(entry.family())) {
480            continue;
481        }
482        if deferred_len < MAX_PLAN_ENTRIES {
483            deferred_ids[deferred_len] = entry.entry_id();
484            deferred_len += 1;
485        }
486    }
487    (blocked, shared, deferred_ids, deferred_len)
488}
489
490fn walk_ready(
491    inventory: &Inventory<'_>,
492    start: u32,
493    present: &[u32],
494    seen: &mut [bool; MAX_PLAN_ENTRIES],
495    cover: &mut [u8; MAX_PLAN_ENTRIES],
496) {
497    let mut stack = [0u32; MAX_PLAN_ENTRIES];
498    let mut sp = 0usize;
499    push_id(inventory, &mut stack, &mut sp, seen, start);
500    while sp > 0 {
501        sp -= 1;
502        let id = stack[sp];
503        let Some(entry) = inventory.entry(id) else {
504            continue;
505        };
506        let readiness = evaluate(inventory, id, Some(entry.family()), present);
507        if readiness == Readiness::Ready {
508            if let Some(idx) = inventory.index_of(id) {
509                cover[idx] = cover[idx].saturating_add(1);
510            }
511        }
512        for edge in inventory.edges() {
513            if edge.from_id() != id {
514                continue;
515            }
516            let dep = edge.to_id();
517            let include = match edge.obligation() {
518                Obligation::Mandatory => true,
519                Obligation::Optional => evaluate(inventory, dep, None, present) == Readiness::Ready,
520            };
521            if include {
522                push_id(inventory, &mut stack, &mut sp, seen, dep);
523            }
524        }
525    }
526}
527
528fn push_id(
529    inventory: &Inventory<'_>,
530    stack: &mut [u32; MAX_PLAN_ENTRIES],
531    sp: &mut usize,
532    seen: &mut [bool; MAX_PLAN_ENTRIES],
533    id: u32,
534) {
535    let Some(idx) = inventory.index_of(id) else {
536        return;
537    };
538    if seen[idx] {
539        return;
540    }
541    if *sp >= MAX_PLAN_ENTRIES {
542        return;
543    }
544    seen[idx] = true;
545    stack[*sp] = id;
546    *sp += 1;
547}
548
549#[cfg(all(test, not(target_arch = "wasm32")))]
550mod mixed_http_tests {
551    //! EvidenceClass::Component (`net/qdnf/harness/qualification.rs`).
552    //! Never Process. Never PhysicalNetwork.
553    use super::{
554        bind_http_entry, entry_admits_family, entry_slice, serve_scheduled, whole_span,
555        AuthenticatedRange, BoundHttpEntry, EntryFamily, FallbackPolicy, HttpMux, HttpObject,
556        InclusiveRange, OutboardNode, ProviderError, ReservationLedger, ServeOptions, ServedObject,
557        Validator, LEAF_BYTES, MAX_SIBLINGS,
558    };
559    use crate::bundle::stream::proof::TreeBuilder;
560    use super::super::{
561        get_range, tls_is_pq_publisher_authority, write_content_range, write_strong_etag,
562        FetchBudget, Fetched, LigGate, RangeRequest, HEADER_CAP, LEGACY_FULL_OBJECT_FALLBACK_BYTES,
563    };
564    use crate::bundle::stream::{
565        descriptor::{
566            CandidateIdentity, ContextParameters, EntryRecord, PageRef, HASH_SCRATCH_BYTES,
567            MAX_ENCODED, MAX_METADATA,
568        },
569        index::{admit_header, admit_index, EntryScratch, ExtentLimit, IndexReadLimits},
570        plan::{
571            DependencyEdge, DependencyReason, Inventory, Obligation, PlanEntry, PlanEntrySpec,
572            PrincipalSelection, RecordUnit, RepresentationClass, ResourceEstimate,
573            SelectionIntent, SelectionRequest,
574        },
575        policy::{
576            adopt_local_whole_source, authenticate_closure, encode_manifest_into, BoundClosure,
577            LocalGrantRequest, ManifestFields, PublicationProof, CLOSURE_PURPOSE, MAX_MANIFEST_BYTES,
578            PUBLICATION_PURPOSE,
579        },
580        publish::{EntryAssignment, PlainPublisher, PublicationClass, PublisherOptions},
581        selection::{select_entry, SelectedPlainEntry},
582    };
583    use crate::bundle::{BundleReadLimits, BundleWriter};
584    use crate::crypto::network::{
585        authority::{LocalBootstrap, PinAuthority, PinConfig, PinHandle},
586        cose,
587        digest::sha384,
588        types::{KeyEpoch, KeyPurpose},
589    };
590    use crate::mini_parser::hash_token;
591    use crate::net::peer::runtime::ResourceBudget;
592    use crate::net::qdnf::authority::AuthorityOwner;
593    use crate::net::qdnf::types::{OperationId, StrongDigest};
594    use crate::q42::q42_volume::{
595        validate_exact_range_response, write_unified_volume, Q42ByteRange, Q42RangeSource,
596        Q42RangeVolume,
597    };
598    use crate::semantic_instruments::resolve::{bounded_closure::*, DependencyKind};
599    use crate::NQuin;
600    use crate::bundle::stream::formats::Q42AuthenticatedRangeSource;
601    use ed25519_dalek::SigningKey;
602    use fips204::{
603        ml_dsa_65,
604        traits::{KeyGen, SerDes},
605    };
606    use std::collections::HashMap;
607    use std::io::{Read, Write};
608    use std::net::{TcpListener, TcpStream};
609    use std::sync::{Arc, Mutex};
610    use std::thread;
611    use std::time::Duration;
612    use tempfile::NamedTempFile;
613
614    const QAC_OPAQUE: &[u8] =
615        include_bytes!("../../../q42/field_envelope/fixtures/candidate/qac_candidate-opaque.qac");
616    const QAC_PCM: &[u8] = include_bytes!(
617        "../../../q42/field_envelope/fixtures/candidate/qac_candidate-pcm-signed-zero.qac"
618    );
619    const EMF_OPAQUE: &[u8] =
620        include_bytes!("../../../q42/field_envelope/fixtures/candidate/emf_candidate-opaque.emf");
621    const EMF_ALIGN: &[u8] = include_bytes!(
622        "../../../q42/field_envelope/fixtures/candidate/emf_candidate-aligned4096.emf"
623    );
624    const M64_BYTES: &[u8] = b"m64-delay-payload-not-a-field";
625
626    const ID_QAC_OPAQUE: u32 = 10;
627    const ID_QAC_PCM: u32 = 11;
628    const ID_EMF_OPAQUE: u32 = 20;
629    const ID_EMF_ALIGN: u32 = 21;
630    const ID_M64: u32 = 30;
631    const ID_Q42: u32 = 40;
632    const ID_CALIB: u32 = 60;
633
634    const PATH: &[u8] = b"/objects/mixed/representations/10";
635
636    struct Scene {
637        nodes: [ClosureNode<'static>; 3],
638        edges: [ClosureEdge; 2],
639        fields: ManifestFields,
640        manifest: Vec<u8>,
641        body: Vec<u8>,
642        source: Vec<u8>,
643        entry_page: Vec<u8>,
644        identity: CandidateIdentity,
645        ml_sk: ml_dsa_65::PrivateKey,
646        ml_pk: [u8; 1952],
647        ed_sk: SigningKey,
648        ed_pk: [u8; 32],
649    }
650
651    impl Scene {
652        fn source(&self) -> &[u8] {
653            &self.source
654        }
655        fn body(&self) -> &[u8] {
656            &self.body
657        }
658        fn entry_page(&self) -> &[u8] {
659            &self.entry_page
660        }
661        fn identity(&self) -> CandidateIdentity {
662            self.identity
663        }
664        fn publish(files: &[(&str, &str, &[u8], u32)]) -> Self {
665            let nodes = [
666                ClosureNode {
667                    digest: sha384(b"root"),
668                    kind: DependencyKind::Instrument,
669                    original_bytes: b"root",
670                },
671                ClosureNode {
672                    digest: sha384(b"policy"),
673                    kind: DependencyKind::LawPackage,
674                    original_bytes: b"policy",
675                },
676                ClosureNode {
677                    digest: sha384(b"consumer"),
678                    kind: DependencyKind::NativeModule,
679                    original_bytes: b"consumer",
680                },
681            ];
682            let edges = [
683                ClosureEdge {
684                    dependent: nodes[0].digest,
685                    dependency: nodes[1].digest,
686                },
687                ClosureEdge {
688                    dependent: nodes[0].digest,
689                    dependency: nodes[2].digest,
690                },
691            ];
692            let mut writer = BundleWriter::new();
693            for (key, kind, bytes, _) in files {
694                writer
695                    .add_file(*key, *kind, bytes.to_vec(), None)
696                    .unwrap();
697            }
698            let source = writer.build().unwrap();
699            let fields = ManifestFields {
700                source: sha384(&source),
701                source_length: source.len() as u64,
702                semantic_root: nodes[0].digest,
703                policy: nodes[1].digest,
704                consumer: nodes[2].digest,
705                issuer: StrongDigest([31; 48]),
706            };
707            let candidate = verify_closure(nodes[0].digest, &nodes, &edges).unwrap();
708            let mut manifest = vec![0; MAX_MANIFEST_BYTES];
709            let n = encode_manifest_into(fields, &candidate, &mut manifest).unwrap();
710            manifest.truncate(n);
711            let parameters = ContextParameters {
712                nonce: [1; 32],
713                generation: 0,
714                predecessor: None,
715                semantic_contract: sha384(&manifest),
716                policy: fields.policy,
717                consumer_profile: fields.consumer,
718            };
719            let assignments: Vec<EntryAssignment> = files
720                .iter()
721                .map(|(_, _, _, id)| EntryAssignment {
722                    id: *id,
723                    inner_version: 1,
724                })
725                .collect();
726            let mut index = vec![EntryScratch::EMPTY; assignments.len()];
727            let mut ids = vec![0u32; assignments.len()];
728            let mut context_refs = [PageRef::EMPTY; 32];
729            let mut entry_refs = [PageRef::EMPTY; 32];
730            let mut publisher = PlainPublisher::prepare(
731                &source,
732                BundleReadLimits::default(),
733                &assignments,
734                PublisherOptions {
735                    parameters,
736                    class: PublicationClass::PlainCandidate,
737                    metadata_limit: MAX_METADATA,
738                },
739                &mut index,
740                &mut ids,
741                &mut context_refs,
742                &mut entry_refs,
743            )
744            .unwrap();
745            let mut output = vec![0; MAX_ENCODED];
746            let mut scratch = vec![0; HASH_SCRATCH_BYTES];
747            for page in 0..publisher.page_count() {
748                publisher
749                    .emit_context_page(page, &mut output, &mut scratch, |_, _| Ok(()))
750                    .unwrap();
751            }
752            let n = publisher
753                .encode_context_root(&mut output, &mut scratch)
754                .unwrap();
755            let context = output[..n].to_vec();
756            let mut entry_page = Vec::new();
757            for page in 0..publisher.page_count() {
758                publisher
759                    .emit_entry_page(
760                        page,
761                        &mut output,
762                        &mut scratch,
763                        |_, _| Ok(()),
764                        |bytes, _| {
765                            entry_page = bytes.to_vec();
766                            Ok(())
767                        },
768                    )
769                    .unwrap();
770            }
771            let identity = publisher
772                .finish(&context, &mut output, &mut scratch)
773                .unwrap();
774            let n = publisher.body_encoded_length(&context).unwrap();
775            let body = output[..n].to_vec();
776            drop(publisher);
777            let (ml_pk, ml_sk) = ml_dsa_65::KG::keygen_from_seed(&[71; 32]);
778            let ed_sk = SigningKey::from_bytes(&[72; 32]);
779            let ed_pk = ed_sk.verifying_key().to_bytes();
780            Self {
781                nodes,
782                edges,
783                fields,
784                manifest,
785                body,
786                source,
787                entry_page,
788                identity,
789                ml_sk,
790                ml_pk: ml_pk.into_bytes(),
791                ed_sk,
792                ed_pk,
793            }
794        }
795        fn keys(&self) -> cose::PairedPublicKeys<'_> {
796            cose::PairedPublicKeys {
797                ml_dsa_65: &self.ml_pk,
798                ed25519: &self.ed_pk,
799            }
800        }
801        fn installed(&self, purpose: &[u8]) -> (PinAuthority, LocalBootstrap, PinHandle, PinHandle) {
802            let (mut pins, admin) = PinAuthority::new_local_bootstrap().unwrap();
803            let handle = pins
804                .install_pin(
805                    &admin,
806                    PinConfig {
807                        principal: self.fields.issuer,
808                        provider_epoch: KeyEpoch {
809                            controller: 7,
810                            epoch: 1,
811                            purpose: KeyPurpose::ControllerSign,
812                        },
813                        keys: self.keys(),
814                        purpose,
815                        audience: b"reader",
816                        not_before_unix: 10,
817                        expires_unix: 100,
818                    },
819                    10,
820                )
821                .unwrap();
822            let publisher = pins
823                .install_pin(
824                    &admin,
825                    PinConfig {
826                        principal: self.fields.issuer,
827                        provider_epoch: KeyEpoch {
828                            controller: 7,
829                            epoch: 1,
830                            purpose: KeyPurpose::ControllerSign,
831                        },
832                        keys: self.keys(),
833                        purpose: PUBLICATION_PURPOSE,
834                        audience: b"reader",
835                        not_before_unix: 10,
836                        expires_unix: 100,
837                    },
838                    10,
839                )
840                .unwrap();
841            (pins, admin, handle, publisher)
842        }
843        fn signed_digest(&self, digest: StrongDigest, purpose: &[u8]) -> Vec<u8> {
844            let binding = cose::Binding {
845                descriptor_digest: &digest.0,
846                key_ids: self.keys().key_ids(),
847                controller_epoch: 1,
848                purpose,
849                audience: b"reader",
850            };
851            let keys = cose::SigningKeys {
852                ml_dsa_65: &self.ml_sk,
853                ed25519: &self.ed_sk,
854            };
855            let mut out = vec![0; cose::MAX_ENVELOPE_BYTES];
856            let n = cose::sign_pair_raw(&binding, &keys, &mut cose::Workspace::new(), &mut out)
857                .unwrap();
858            out.truncate(n);
859            out
860        }
861        fn authenticated<'a>(
862            &'a self,
863            pins: &PinAuthority,
864            pin: PinHandle,
865            now: u64,
866        ) -> crate::bundle::stream::policy::AuthenticatedClosure<'a> {
867            let candidate =
868                verify_closure(self.fields.semantic_root, &self.nodes, &self.edges).unwrap();
869            let signed = self.signed_digest(sha384(&self.manifest), CLOSURE_PURPOSE);
870            authenticate_closure(
871                candidate,
872                &self.manifest,
873                pins,
874                pin,
875                self.keys().key_ids(),
876                1,
877                b"reader",
878                &signed,
879                now,
880                &mut cose::Workspace::new(),
881            )
882            .unwrap()
883        }
884        fn bound<'a>(
885            &'a self,
886            pins: &PinAuthority,
887            pin: PinHandle,
888            publisher: PinHandle,
889        ) -> BoundClosure<'a> {
890            self.authenticated(pins, pin, 10)
891                .bind_descriptor(
892                    self.identity,
893                    &self.body,
894                    &mut vec![0; HASH_SCRATCH_BYTES],
895                    pins,
896                    self.publication(
897                        publisher,
898                        &self.signed_digest(self.identity.descriptor_id(), PUBLICATION_PURPOSE),
899                    ),
900                    10,
901                    &mut cose::Workspace::new(),
902                )
903                .unwrap()
904        }
905        fn publication<'a>(&self, pin: PinHandle, envelope: &'a [u8]) -> PublicationProof<'a> {
906            PublicationProof {
907                pin,
908                key_ids: self.keys().key_ids(),
909                epoch: 1,
910                audience: b"reader",
911                envelope,
912            }
913        }
914        fn request(&self) -> LocalGrantRequest {
915            LocalGrantRequest {
916                principal: StrongDigest([41; 48]),
917                recipient: StrongDigest([42; 48]),
918                purpose: sha384(b"local-read"),
919                operation: OperationId([1; 16]),
920                not_before: 10,
921                expires: 90,
922                resource_ceiling: self.fields.source_length,
923            }
924        }
925    }
926
927    fn four_live() -> [(&'static str, &'static str, &'static [u8], u32); 4] {
928        [
929            ("qac-opaque", "qac", QAC_OPAQUE, ID_QAC_OPAQUE),
930            ("qac-pcm", "qac", QAC_PCM, ID_QAC_PCM),
931            ("emf-opaque", "emf", EMF_OPAQUE, ID_EMF_OPAQUE),
932            ("emf-align", "emf", EMF_ALIGN, ID_EMF_ALIGN),
933        ]
934    }
935
936    fn q42_volume_bytes() -> Vec<u8> {
937        let subject = hash_token("urn:q42:authenticated-subject");
938        let predicate = hash_token("urn:q42:authenticated-predicate");
939        let object = hash_token("urn:q42:authenticated-object");
940        let quin = NQuin {
941            subject,
942            predicate,
943            object,
944            context: 0,
945            metadata: 0,
946            parity: 0,
947        };
948        let mut lexicon = HashMap::new();
949        lexicon.insert(subject, "urn:q42:authenticated-subject".to_string());
950        lexicon.insert(predicate, "urn:q42:authenticated-predicate".to_string());
951        lexicon.insert(object, "urn:q42:authenticated-object".to_string());
952        let file = NamedTempFile::new().unwrap();
953        write_unified_volume(file.path(), &lexicon, &[(object, object)], &[vec![quin]]).unwrap();
954        let mut q42 = Vec::new();
955        std::fs::File::open(file.path())
956            .unwrap()
957            .read_to_end(&mut q42)
958            .unwrap();
959        assert!(!q42.is_empty());
960        assert!(q42.len() as u64 <= LEAF_BYTES);
961        assert!(q42.len() as u64 <= LEGACY_FULL_OBJECT_FALLBACK_BYTES);
962        q42
963    }
964
965    fn family_of(id: u32) -> EntryFamily {
966        match id {
967            ID_QAC_OPAQUE | ID_QAC_PCM => EntryFamily::Qac,
968            ID_EMF_OPAQUE | ID_EMF_ALIGN => EntryFamily::Emf,
969            ID_M64 => EntryFamily::M64,
970            ID_Q42 => EntryFamily::Q42,
971            ID_CALIB => EntryFamily::Q42,
972            _ => EntryFamily::Opaque,
973        }
974    }
975
976    fn plan_entry(
977        candidate: CandidateIdentity,
978        entry_id: u32,
979        family: EntryFamily,
980        role: RepresentationClass,
981        obligation: Obligation,
982        bytes: u64,
983    ) -> PlanEntry {
984        PlanEntry::new(PlanEntrySpec {
985            candidate,
986            entry_id,
987            family,
988            role,
989            interval: None,
990            timebase: None,
991            estimate: ResourceEstimate::new(bytes, 1, 1),
992            obligation,
993        })
994        .unwrap()
995    }
996
997    fn select_all<'p>(bound: &BoundClosure<'_>, scene: &'p Scene) -> Vec<SelectedPlainEntry<'p>> {
998        let header = admit_header(
999            &scene.source()[..64],
1000            scene.source().len() as u64,
1001            ExtentLimit::default(),
1002            IndexReadLimits::default(),
1003        )
1004        .unwrap();
1005        let count = scene.identity().entry_count() as usize;
1006        let mut index_scratch = vec![EntryScratch::EMPTY; count];
1007        let index = admit_index(
1008            &header,
1009            &scene.source()[header.index_offset() as usize..],
1010            IndexReadLimits::default(),
1011            &mut index_scratch,
1012        )
1013        .unwrap();
1014        let mut rows = [EntryRecord::EMPTY; 128];
1015        let mut framing = vec![0; HASH_SCRATCH_BYTES];
1016        let mut out = Vec::with_capacity(count);
1017        for ordinal in 0..count as u32 {
1018            out.push(
1019                select_entry(
1020                    bound,
1021                    scene.body(),
1022                    &scene.source()[..64],
1023                    &index,
1024                    scene.entry_page(),
1025                    ordinal,
1026                    &mut rows,
1027                    &mut framing,
1028                )
1029                .unwrap(),
1030            );
1031        }
1032        out
1033    }
1034
1035    fn build_outboard(
1036        source: &[u8],
1037        selected: SelectedPlainEntry<'_>,
1038    ) -> (Vec<OutboardNode>, StrongDigest) {
1039        let entry = entry_slice(source, selected).unwrap();
1040        let spec = selected.tree_spec().unwrap();
1041        let mut builder = TreeBuilder::new(spec);
1042        let mut nodes = Vec::new();
1043        for leaf in entry.chunks(LEAF_BYTES as usize) {
1044            builder
1045                .append(leaf, |node| {
1046                    nodes.push(node);
1047                    Ok(())
1048                })
1049                .unwrap();
1050        }
1051        let root = builder
1052            .finish(|node| {
1053                nodes.push(node);
1054                Ok(())
1055            })
1056            .unwrap();
1057        assert_eq!(root, selected.root());
1058        nodes.sort_unstable_by_key(|node| (node.start_leaf, node.leaf_count));
1059        (nodes, root)
1060    }
1061
1062    fn outboards(
1063        source: &[u8],
1064        selected: &[SelectedPlainEntry<'_>],
1065    ) -> (Vec<Vec<OutboardNode>>, Vec<StrongDigest>) {
1066        let mut nodes = Vec::new();
1067        let mut roots = Vec::new();
1068        for sel in selected {
1069            let (n, r) = build_outboard(source, *sel);
1070            nodes.push(n);
1071            roots.push(r);
1072        }
1073        (nodes, roots)
1074    }
1075
1076    fn bind_entries<'src, 'sel, 'nodes, 'meta>(
1077        source: &'src [u8],
1078        selected: &[SelectedPlainEntry<'sel>],
1079        nodes: &'nodes [Vec<OutboardNode>],
1080        roots: &[StrongDigest],
1081        descriptor: &'meta [u8],
1082        entry_page: &'meta [u8],
1083    ) -> Vec<BoundHttpEntry<'src, 'sel, 'nodes, 'meta>> {
1084        selected
1085            .iter()
1086            .zip(nodes.iter())
1087            .zip(roots.iter())
1088            .map(|((sel, nodes), root)| {
1089                bind_http_entry(source, *sel, nodes, *root, descriptor, entry_page).unwrap()
1090            })
1091            .collect()
1092    }
1093
1094    fn present_admitted(source: &[u8], selected: &[SelectedPlainEntry<'_>]) -> Vec<u32> {
1095        let mut present = Vec::new();
1096        for sel in selected {
1097            let family = family_of(sel.entry_id());
1098            if family == EntryFamily::Qac
1099                || family == EntryFamily::Emf
1100                || family == EntryFamily::Q42
1101            {
1102                if entry_admits_family(source, *sel, family) {
1103                    present.push(sel.entry_id());
1104                }
1105            } else if family != EntryFamily::Opaque {
1106                present.push(sel.entry_id());
1107            }
1108        }
1109        present
1110    }
1111
1112    fn live_plan(
1113        candidate: CandidateIdentity,
1114        ids: &[u32],
1115        selected: &[SelectedPlainEntry<'_>],
1116    ) -> Vec<PlanEntry> {
1117        ids.iter()
1118            .map(|id| {
1119                let bytes = selected
1120                    .iter()
1121                    .find(|s| s.entry_id() == *id)
1122                    .map(|s| s.logical_length())
1123                    .unwrap_or(1);
1124                plan_entry(
1125                    candidate,
1126                    *id,
1127                    family_of(*id),
1128                    RepresentationClass::Base,
1129                    Obligation::Mandatory,
1130                    bytes,
1131                )
1132            })
1133            .collect()
1134    }
1135
1136    fn selected_by_id<'p>(
1137        selected: &[SelectedPlainEntry<'p>],
1138        id: u32,
1139    ) -> SelectedPlainEntry<'p> {
1140        *selected.iter().find(|s| s.entry_id() == id).unwrap()
1141    }
1142
1143    fn ledger() -> ReservationLedger {
1144        let cap = ResourceBudget {
1145            bytes: 8 << 20,
1146            work: 64,
1147            io: 64,
1148        };
1149        ReservationLedger::new(cap, cap, cap, cap, cap)
1150    }
1151
1152    fn spawn_http(
1153        status: u16,
1154        hdrs: Vec<(String, String)>,
1155        body: Vec<u8>,
1156    ) -> (
1157        std::net::SocketAddr,
1158        Arc<Mutex<Vec<u8>>>,
1159        thread::JoinHandle<()>,
1160    ) {
1161        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
1162        let addr = listener.local_addr().unwrap();
1163        let captured = Arc::new(Mutex::new(Vec::new()));
1164        let cap = captured.clone();
1165        let th = thread::spawn(move || {
1166            let (mut s, _) = listener.accept().unwrap();
1167            s.set_read_timeout(Some(Duration::from_secs(2))).ok();
1168            s.set_write_timeout(Some(Duration::from_secs(2))).ok();
1169            let mut buf = [0u8; HEADER_CAP];
1170            let mut n = 0;
1171            while n < buf.len() {
1172                match s.read(&mut buf[n..]) {
1173                    Ok(0) => break,
1174                    Ok(k) => {
1175                        n += k;
1176                        if buf[..n].windows(4).any(|w| w == b"\r\n\r\n") {
1177                            break;
1178                        }
1179                    }
1180                    Err(_) => break,
1181                }
1182            }
1183            *cap.lock().unwrap() = buf[..n].to_vec();
1184            let mut resp = format!("HTTP/1.1 {status} X\r\n");
1185            for (k, v) in &hdrs {
1186                resp.push_str(k);
1187                resp.push_str(": ");
1188                resp.push_str(v);
1189                resp.push_str("\r\n");
1190            }
1191            resp.push_str("\r\n");
1192            let _ = s.write_all(resp.as_bytes());
1193            let _ = s.write_all(&body);
1194            let _ = s.flush();
1195        });
1196        (addr, captured, th)
1197    }
1198
1199    fn connect(addr: std::net::SocketAddr) -> TcpStream {
1200        let s = TcpStream::connect(addr).unwrap();
1201        s.set_read_timeout(Some(Duration::from_secs(2))).unwrap();
1202        s.set_write_timeout(Some(Duration::from_secs(2))).unwrap();
1203        s
1204    }
1205
1206    fn object_body<'a>(out: &'a [u8], object: &ServedObject) -> &'a [u8] {
1207        &out[object.body_off..object.body_off + object.body_len]
1208    }
1209
1210    #[test]
1211    fn schedule_order_matches_native_bytes_over_http() {
1212        assert!(!tls_is_pq_publisher_authority());
1213        let scene = Scene::publish(&four_live());
1214        let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1215        let bound = scene.bound(&pins, pin, publisher);
1216        let local = select_all(&bound, &scene);
1217        assert_eq!(local.len(), 4);
1218        let (nodes, roots) = outboards(scene.source(), &local);
1219        let entries = bind_entries(
1220            scene.source(),
1221            &local,
1222            &nodes,
1223            &roots,
1224            scene.body(),
1225            scene.entry_page(),
1226        );
1227        let present = present_admitted(scene.source(), &local);
1228        assert_eq!(present.len(), 4);
1229        let ids = [ID_QAC_OPAQUE, ID_QAC_PCM, ID_EMF_OPAQUE, ID_EMF_ALIGN];
1230        let plan_entries = live_plan(scene.identity(), &ids, &local);
1231        let inv = Inventory::compile(scene.identity(), &plan_entries, &[]).unwrap();
1232        let intents = [
1233            SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1234            SelectionIntent::scene(ID_QAC_PCM, EntryFamily::Qac, None, None).unwrap(),
1235            SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1236            SelectionIntent::scene(ID_EMF_ALIGN, EntryFamily::Emf, None, None).unwrap(),
1237        ];
1238        let request = SelectionRequest::scene(&intents).unwrap();
1239        let sel = PrincipalSelection::new(1, request).unwrap();
1240        let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1241            Ok(m) => m,
1242            Err(_) => panic!("four live families must compile"),
1243        };
1244        mux.push_control(1, RecordUnit::at(0)).unwrap();
1245        let mut owner = AuthorityOwner::new();
1246        let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1247        let mut ledger = ledger();
1248        let mut out = vec![0u8; 64 * 1024];
1249        let report = match serve_scheduled(
1250            &mut mux,
1251            &entries,
1252            &mut grant,
1253            &pins,
1254            || 20,
1255            &mut ledger,
1256            &mut out,
1257        ) {
1258            Ok(r) => r,
1259            Err(_) => panic!("four live families must serve over HTTP"),
1260        };
1261        assert_eq!(report.control, 1);
1262        assert_eq!(report.transferred, 4);
1263        if report.order_len > 0 {
1264            assert_eq!(report.order[0], None);
1265        }
1266        let mut saw_qac = 0u16;
1267        let mut saw_emf = 0u16;
1268        for i in 0..report.order_len as usize {
1269            match report.order[i] {
1270                None => {}
1271                Some(EntryFamily::Qac) => saw_qac += 1,
1272                Some(EntryFamily::Emf) => saw_emf += 1,
1273                Some(_) => panic!("only QAC/EMF/Control in this scene"),
1274            }
1275        }
1276        assert_eq!(saw_qac, 2);
1277        assert_eq!(saw_emf, 2);
1278        let mut charged = 0u64;
1279        let mut first_object = None;
1280        for i in 0..report.objects_len as usize {
1281            let object = match report.objects[i] {
1282                Some(o) => o,
1283                None => panic!("served object slot"),
1284            };
1285            assert!(object.status == 206 || object.status == 200);
1286            let sel = selected_by_id(&local, object.entry_id);
1287            let native = entry_slice(scene.source(), sel).unwrap();
1288            assert_eq!(object_body(&out, &object), native);
1289            assert!(entry_admits_family(scene.source(), sel, object.family));
1290            charged = charged.saturating_add(object.body_len as u64);
1291            if first_object.is_none() {
1292                first_object = Some((object, native.to_vec()));
1293            }
1294        }
1295        assert_eq!(ledger.used().host.bytes, charged);
1296
1297        let (object, native) = match first_object {
1298            Some(v) => v,
1299            None => panic!("at least one representation"),
1300        };
1301        let mut cr = [0u8; 80];
1302        let range = InclusiveRange::from_start_length(0, native.len() as u64).unwrap();
1303        let cn = write_content_range(range, native.len() as u64, &mut cr).unwrap();
1304        let etag_s = std::str::from_utf8(&object.etag[..object.etag_len])
1305            .unwrap()
1306            .to_string();
1307        let (addr, captured, th) = spawn_http(
1308            object.status,
1309            vec![
1310                (
1311                    "Content-Range".into(),
1312                    String::from_utf8_lossy(&cr[..cn]).into_owned(),
1313                ),
1314                ("Content-Length".into(), native.len().to_string()),
1315                ("Content-Encoding".into(), "identity".into()),
1316                ("ETag".into(), etag_s),
1317            ],
1318            native.clone(),
1319        );
1320        let host = format!("{addr}").into_bytes();
1321        let req = RangeRequest {
1322            host: &host,
1323            path: PATH,
1324            range,
1325            pinned_total: native.len() as u64,
1326            if_range: Some(&object.etag[..object.etag_len]),
1327            expected: Validator {
1328                etag: Some(&object.etag[..object.etag_len]),
1329                last_modified: None,
1330            },
1331            fallback: FallbackPolicy::FORBIDDEN,
1332            budget: FetchBudget {
1333                max_body: LEGACY_FULL_OBJECT_FALLBACK_BYTES,
1334                max_headers: HEADER_CAP,
1335            },
1336            lig: LigGate::consented_active(),
1337        };
1338        let mut stream = connect(addr);
1339        let mut client_out = vec![0u8; native.len()];
1340        let got = match get_range(&mut stream, &req, &mut client_out) {
1341            Ok(v) => v,
1342            Err(_) => panic!("hostile loopback must return the native slice"),
1343        };
1344        assert_eq!(
1345            got,
1346            Fetched::Partial {
1347                length: native.len()
1348            }
1349        );
1350        assert_eq!(&client_out[..native.len()], native.as_slice());
1351        let text = String::from_utf8_lossy(&captured.lock().unwrap()).into_owned();
1352        assert!(text.contains("Accept-Encoding: identity"));
1353        assert!(text.contains("Range: bytes="));
1354        assert!(text.contains("If-Range: "));
1355        assert!(!text.contains("Authorization:"));
1356        th.join().unwrap();
1357    }
1358
1359    #[test]
1360    fn http_delays_m64_while_ready_qac_and_emf_continue() {
1361        let mut files = four_live().to_vec();
1362        files.push(("m64-delay", "blob", M64_BYTES, ID_M64));
1363        let scene = Scene::publish(&files);
1364        let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1365        let bound = scene.bound(&pins, pin, publisher);
1366        let local = select_all(&bound, &scene);
1367        let (nodes, roots) = outboards(scene.source(), &local);
1368        let entries = bind_entries(
1369            scene.source(),
1370            &local,
1371            &nodes,
1372            &roots,
1373            scene.body(),
1374            scene.entry_page(),
1375        );
1376        let present = present_admitted(scene.source(), &local);
1377        assert!(present.contains(&ID_QAC_OPAQUE));
1378        assert!(present.contains(&ID_EMF_OPAQUE));
1379        assert!(present.contains(&ID_M64));
1380        let ids = [
1381            ID_QAC_OPAQUE,
1382            ID_QAC_PCM,
1383            ID_EMF_OPAQUE,
1384            ID_EMF_ALIGN,
1385            ID_M64,
1386        ];
1387        let plan_entries = live_plan(scene.identity(), &ids, &local);
1388        let inv = Inventory::compile(scene.identity(), &plan_entries, &[]).unwrap();
1389        let intents = [
1390            SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1391            SelectionIntent::scene(ID_QAC_PCM, EntryFamily::Qac, None, None).unwrap(),
1392            SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1393            SelectionIntent::scene(ID_EMF_ALIGN, EntryFamily::Emf, None, None).unwrap(),
1394            SelectionIntent::scene(ID_M64, EntryFamily::M64, None, None).unwrap(),
1395        ];
1396        let request = SelectionRequest::scene(&intents).unwrap();
1397        let sel = PrincipalSelection::new(1, request).unwrap();
1398        let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1399            Ok(m) => m,
1400            Err(_) => panic!("live QAC/EMF plus delayed M64 must compile"),
1401        };
1402        mux.push_control(1, RecordUnit::at(0)).unwrap();
1403        let mut owner = AuthorityOwner::new();
1404        let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1405        let mut ledger = ledger();
1406        let mut out = vec![0u8; 64 * 1024];
1407        let report = match serve_scheduled(
1408            &mut mux,
1409            &entries,
1410            &mut grant,
1411            &pins,
1412            || 20,
1413            &mut ledger,
1414            &mut out,
1415        ) {
1416            Ok(r) => r,
1417            Err(_) => panic!("live QAC/EMF plus delayed M64 must serve"),
1418        };
1419        assert!(report.delayed_deferred >= 1);
1420        assert_eq!(report.control, 1);
1421        assert_eq!(report.transferred, 5);
1422        let mut saw_m64 = false;
1423        for i in 0..report.order_len as usize {
1424            match report.order[i] {
1425                None | Some(EntryFamily::Qac) | Some(EntryFamily::Emf) => {
1426                    assert!(!saw_m64, "M64 must wait on live families");
1427                }
1428                Some(EntryFamily::M64) => {
1429                    assert!(i > 0, "Control/QAC/EMF run before M64");
1430                    saw_m64 = true;
1431                }
1432                Some(_) => panic!("unexpected family in delay scene"),
1433            }
1434        }
1435        assert!(saw_m64);
1436        let first_body = match report.objects[0] {
1437            Some(o) => o,
1438            None => panic!("first served representation"),
1439        };
1440        assert!(
1441            first_body.family == EntryFamily::Qac || first_body.family == EntryFamily::Emf,
1442            "first HTTP body is a live family"
1443        );
1444    }
1445
1446    #[test]
1447    fn http_cancel_obsolete_qac_skips_body() {
1448        let scene = Scene::publish(&four_live());
1449        let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1450        let bound = scene.bound(&pins, pin, publisher);
1451        let local = select_all(&bound, &scene);
1452        let (nodes, roots) = outboards(scene.source(), &local);
1453        let entries = bind_entries(
1454            scene.source(),
1455            &local,
1456            &nodes,
1457            &roots,
1458            scene.body(),
1459            scene.entry_page(),
1460        );
1461        let present = present_admitted(scene.source(), &local);
1462        let ids = [ID_QAC_OPAQUE, ID_QAC_PCM, ID_EMF_OPAQUE, ID_EMF_ALIGN];
1463        let plan_entries = live_plan(scene.identity(), &ids, &local);
1464        let inv = Inventory::compile(scene.identity(), &plan_entries, &[]).unwrap();
1465        let intents = [
1466            SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1467            SelectionIntent::scene(ID_QAC_PCM, EntryFamily::Qac, None, None).unwrap(),
1468            SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1469            SelectionIntent::scene(ID_EMF_ALIGN, EntryFamily::Emf, None, None).unwrap(),
1470        ];
1471        let request = SelectionRequest::scene(&intents).unwrap();
1472        let sel = PrincipalSelection::new(1, request).unwrap();
1473        let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1474            Ok(m) => m,
1475            Err(_) => panic!("cancel scene must compile"),
1476        };
1477        let cancelled = mux.cancel(ID_QAC_OPAQUE, None);
1478        assert!(cancelled >= 1);
1479        assert!(mux.occupancy_retained(1, Some(ID_QAC_OPAQUE), 0));
1480        let mut owner = AuthorityOwner::new();
1481        let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1482        let mut ledger = ledger();
1483        let mut out = vec![0u8; 64 * 1024];
1484        let report = match serve_scheduled(
1485            &mut mux,
1486            &entries,
1487            &mut grant,
1488            &pins,
1489            || 20,
1490            &mut ledger,
1491            &mut out,
1492        ) {
1493            Ok(r) => r,
1494            Err(_) => panic!("sibling EMF must continue after QAC cancel"),
1495        };
1496        assert!(report.cancelled_skipped >= 1);
1497        assert_eq!(report.transferred, 3);
1498        let mut saw_emf = 0u16;
1499        let mut saw_qac = 0u16;
1500        for i in 0..report.objects_len as usize {
1501            let object = match report.objects[i] {
1502                Some(o) => o,
1503                None => panic!("served object slot"),
1504            };
1505            assert_ne!(object.entry_id, ID_QAC_OPAQUE);
1506            assert!(object.status == 206 || object.status == 200);
1507            let sel = selected_by_id(&local, object.entry_id);
1508            let native = entry_slice(scene.source(), sel).unwrap();
1509            assert_eq!(object_body(&out, &object), native);
1510            match object.family {
1511                EntryFamily::Qac => saw_qac += 1,
1512                EntryFamily::Emf => saw_emf += 1,
1513                _ => panic!("unexpected family after cancel"),
1514            }
1515        }
1516        assert_eq!(saw_emf, 2);
1517        assert_eq!(saw_qac, 1);
1518        assert!(mux.occupancy_retained(1, Some(ID_QAC_OPAQUE), 0));
1519        mux.acknowledge_complete(1, Some(ID_QAC_OPAQUE), 0).unwrap();
1520        assert!(!mux.occupancy_retained(1, Some(ID_QAC_OPAQUE), 0));
1521    }
1522
1523    #[test]
1524    fn http_incomplete_mandatory_is_not_200_or_206() {
1525        let scene = Scene::publish(&four_live());
1526        let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1527        let bound = scene.bound(&pins, pin, publisher);
1528        let local = select_all(&bound, &scene);
1529        let (nodes, roots) = outboards(scene.source(), &local);
1530        let entries = bind_entries(
1531            scene.source(),
1532            &local,
1533            &nodes,
1534            &roots,
1535            scene.body(),
1536            scene.entry_page(),
1537        );
1538        let present = present_admitted(scene.source(), &local);
1539        let mut plan_entries = live_plan(scene.identity(), &present, &local);
1540        plan_entries.push(plan_entry(
1541            scene.identity(),
1542            ID_CALIB,
1543            EntryFamily::Q42,
1544            RepresentationClass::Metadata,
1545            Obligation::Mandatory,
1546            7,
1547        ));
1548        let qac0 = plan_entries
1549            .iter()
1550            .find(|e| e.entry_id() == ID_QAC_OPAQUE)
1551            .copied()
1552            .unwrap();
1553        let emf0 = plan_entries
1554            .iter()
1555            .find(|e| e.entry_id() == ID_EMF_OPAQUE)
1556            .copied()
1557            .unwrap();
1558        let calib = plan_entries
1559            .iter()
1560            .find(|e| e.entry_id() == ID_CALIB)
1561            .copied()
1562            .unwrap();
1563        let edges = [
1564            DependencyEdge::bind(
1565                &qac0,
1566                &calib,
1567                Obligation::Mandatory,
1568                DependencyReason::Calibration,
1569            )
1570            .unwrap(),
1571            DependencyEdge::bind(
1572                &emf0,
1573                &calib,
1574                Obligation::Mandatory,
1575                DependencyReason::Calibration,
1576            )
1577            .unwrap(),
1578        ];
1579        let inv = Inventory::compile(scene.identity(), &plan_entries, &edges).unwrap();
1580        let intents = [
1581            SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1582            SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1583        ];
1584        let request = SelectionRequest::scene(&intents).unwrap();
1585        let sel = PrincipalSelection::new(1, request).unwrap();
1586        let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1587            Ok(m) => m,
1588            Err(_) => panic!("incomplete scene still compiles; serve must refuse"),
1589        };
1590        let mut owner = AuthorityOwner::new();
1591        let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1592        let mut ledger = ledger();
1593        let mut out = [0xA5u8; 64];
1594        match serve_scheduled(
1595            &mut mux,
1596            &entries,
1597            &mut grant,
1598            &pins,
1599            || 20,
1600            &mut ledger,
1601            &mut out,
1602        ) {
1603            Err(ProviderError::Policy) | Err(ProviderError::Unsatisfiable) => {}
1604            Ok(_) => panic!("missing mandatory must not disclose 200/206"),
1605            Err(_) => panic!("missing mandatory maps to Policy or Unsatisfiable"),
1606        }
1607        assert!(out.iter().all(|b| *b == 0xA5));
1608        assert_eq!(ledger.used().host.bytes, 0);
1609    }
1610
1611    #[test]
1612    fn http_two_qac_and_two_emf_are_distinct_objects() {
1613        let scene = Scene::publish(&four_live());
1614        let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1615        let bound = scene.bound(&pins, pin, publisher);
1616        let local = select_all(&bound, &scene);
1617        let (nodes, roots) = outboards(scene.source(), &local);
1618        let entries = bind_entries(
1619            scene.source(),
1620            &local,
1621            &nodes,
1622            &roots,
1623            scene.body(),
1624            scene.entry_page(),
1625        );
1626        let present = present_admitted(scene.source(), &local);
1627        let ids = [ID_QAC_OPAQUE, ID_QAC_PCM, ID_EMF_OPAQUE, ID_EMF_ALIGN];
1628        let plan_entries = live_plan(scene.identity(), &ids, &local);
1629        let inv = Inventory::compile(scene.identity(), &plan_entries, &[]).unwrap();
1630        let intents = [
1631            SelectionIntent::scene(ID_QAC_OPAQUE, EntryFamily::Qac, None, None).unwrap(),
1632            SelectionIntent::scene(ID_QAC_PCM, EntryFamily::Qac, None, None).unwrap(),
1633            SelectionIntent::scene(ID_EMF_OPAQUE, EntryFamily::Emf, None, None).unwrap(),
1634            SelectionIntent::scene(ID_EMF_ALIGN, EntryFamily::Emf, None, None).unwrap(),
1635        ];
1636        let request = SelectionRequest::scene(&intents).unwrap();
1637        let sel = PrincipalSelection::new(1, request).unwrap();
1638        let mut mux = match HttpMux::compile(&inv, &[sel], &present) {
1639            Ok(m) => m,
1640            Err(_) => panic!("four distinct objects must compile"),
1641        };
1642        let mut owner = AuthorityOwner::new();
1643        let mut grant = adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1644        let mut ledger = ledger();
1645        let mut out = vec![0u8; 64 * 1024];
1646        let report = match serve_scheduled(
1647            &mut mux,
1648            &entries,
1649            &mut grant,
1650            &pins,
1651            || 20,
1652            &mut ledger,
1653            &mut out,
1654        ) {
1655            Ok(r) => r,
1656            Err(_) => panic!("four distinct objects must serve"),
1657        };
1658        assert_eq!(report.transferred, 4);
1659        assert_eq!(report.objects_len, 4);
1660        let mut ids_seen = [0u32; 4];
1661        let mut etags = [[0u8; 98]; 4];
1662        let mut roots_seen = [StrongDigest::ZERO; 4];
1663        for i in 0..4 {
1664            let object = match report.objects[i] {
1665                Some(o) => o,
1666                None => panic!("four objects"),
1667            };
1668            assert!(object.status == 206 || object.status == 200);
1669            ids_seen[i] = object.entry_id;
1670            etags[i] = object.etag;
1671            let sel = selected_by_id(&local, object.entry_id);
1672            roots_seen[i] = sel.root();
1673            let native = entry_slice(scene.source(), sel).unwrap();
1674            assert_eq!(object_body(&out, &object), native);
1675            let mut expect_etag = [0u8; 98];
1676            write_strong_etag(sel.root(), &mut expect_etag).unwrap();
1677            assert_eq!(&object.etag[..object.etag_len], &expect_etag[..98]);
1678        }
1679        for i in 0..4 {
1680            for j in 0..i {
1681                assert_ne!(ids_seen[i], ids_seen[j]);
1682                assert_ne!(etags[i], etags[j]);
1683                assert_ne!(roots_seen[i], roots_seen[j]);
1684            }
1685        }
1686        let mut saw_qac = 0u16;
1687        let mut saw_emf = 0u16;
1688        for i in 0..4 {
1689            match report.objects[i].map(|o| o.family) {
1690                Some(EntryFamily::Qac) => saw_qac += 1,
1691                Some(EntryFamily::Emf) => saw_emf += 1,
1692                _ => panic!("only QAC/EMF objects"),
1693            }
1694        }
1695        assert_eq!(saw_qac, 2);
1696        assert_eq!(saw_emf, 2);
1697    }
1698
1699    #[test]
1700    fn http_q42_range_matches_authenticated_source() {
1701        assert!(!tls_is_pq_publisher_authority());
1702        let q42 = q42_volume_bytes();
1703        assert!(q42.len() > 256);
1704        let take = 128usize;
1705        let mut files = four_live().to_vec();
1706        files.push(("q42-query", "q42", q42.as_slice(), ID_Q42));
1707        let scene = Scene::publish(&files);
1708        let (pins, _, pin, publisher) = scene.installed(CLOSURE_PURPOSE);
1709        let bound = scene.bound(&pins, pin, publisher);
1710        let local = select_all(&bound, &scene);
1711        let selected = selected_by_id(&local, ID_Q42);
1712        let payload = entry_slice(scene.source(), selected).unwrap();
1713        assert_eq!(payload, q42.as_slice());
1714        assert!(entry_admits_family(scene.source(), selected, EntryFamily::Q42));
1715
1716        let mut siblings = [StrongDigest::ZERO; MAX_SIBLINGS];
1717        let span = match whole_span(selected, payload, &mut siblings) {
1718            Ok(s) => s,
1719            Err(_) => panic!("q42 whole-entry span"),
1720        };
1721        let whole = match AuthenticatedRange::new(selected, &span, 0, payload.len()) {
1722            Ok(r) => r,
1723            Err(_) => panic!("q42 whole-entry authenticated range"),
1724        };
1725        let ranges = [whole];
1726        let source = match Q42AuthenticatedRangeSource::new(
1727            selected,
1728            &ranges,
1729            q42.len() as u64,
1730            1,
1731        ) {
1732            Ok(s) => s,
1733            Err(_) => panic!("q42 authenticated range source"),
1734        };
1735        let volume = match Q42RangeVolume::open(source) {
1736            Ok(v) => v,
1737            Err(_) => panic!("whole-entry q42 must open"),
1738        };
1739        assert!(volume.block_count() >= 1);
1740        let source = volume.into_source();
1741        let mut native_window = vec![0u8; take];
1742        match source.read_exact_at(0, &mut native_window) {
1743            Ok(()) => {}
1744            Err(_) => panic!("authenticated q42 window"),
1745        }
1746        match source.read_range_into(
1747            Q42ByteRange {
1748                offset: 0,
1749                length: take,
1750            },
1751            &mut native_window,
1752        ) {
1753            Ok(()) => {}
1754            Err(_) => panic!("authenticated q42 read_range_into"),
1755        }
1756        assert_eq!(&native_window, &q42[..take]);
1757
1758        let left = match AuthenticatedRange::new(selected, &span, 0, 8) {
1759            Ok(r) => r,
1760            Err(_) => panic!("q42 left span"),
1761        };
1762        let right_start = q42.len().saturating_sub(8);
1763        let right = match AuthenticatedRange::new(
1764            selected,
1765            &span,
1766            right_start as u64,
1767            q42.len() - right_start,
1768        ) {
1769            Ok(r) => r,
1770            Err(_) => panic!("q42 right span"),
1771        };
1772        let sparse_ranges = [left, right];
1773        let sparse = match Q42AuthenticatedRangeSource::new(
1774            selected,
1775            &sparse_ranges,
1776            q42.len() as u64,
1777            2,
1778        ) {
1779            Ok(s) => s,
1780            Err(_) => panic!("q42 sparse source"),
1781        };
1782        let mut untouched = [0xa5u8; 4];
1783        match sparse.read_exact_at(8, &mut untouched) {
1784            Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof),
1785            Ok(()) => panic!("gap must not be a complete q42 answer"),
1786        }
1787        assert_eq!(untouched, [0xa5u8; 4]);
1788
1789        let partial = match AuthenticatedRange::new(selected, &span, 0, take) {
1790            Ok(r) => r,
1791            Err(_) => panic!("q42 partial range"),
1792        };
1793        let partial_ranges = [partial];
1794        let partial_source = match Q42AuthenticatedRangeSource::new(
1795            selected,
1796            &partial_ranges,
1797            q42.len() as u64,
1798            1,
1799        ) {
1800            Ok(s) => s,
1801            Err(_) => panic!("q42 partial source"),
1802        };
1803        match Q42RangeVolume::open(partial_source) {
1804            Err(_) => {}
1805            Ok(_) => panic!("partial header/lex window must not open as a complete volume"),
1806        }
1807        let partial_source = match Q42AuthenticatedRangeSource::new(
1808            selected,
1809            &partial_ranges,
1810            q42.len() as u64,
1811            1,
1812        ) {
1813            Ok(s) => s,
1814            Err(_) => panic!("q42 partial source retry"),
1815        };
1816        let mut beyond = [0xa5u8; 4];
1817        match partial_source.read_exact_at(take as u64, &mut beyond) {
1818            Err(e) => assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof),
1819            Ok(()) => panic!("uncovered q42 bytes must not silently complete"),
1820        }
1821        assert_eq!(beyond, [0xa5u8; 4]);
1822
1823        let (nodes, root) = build_outboard(scene.source(), selected);
1824        let bound_entry = match bind_http_entry(
1825            scene.source(),
1826            selected,
1827            &nodes,
1828            root,
1829            scene.body(),
1830            scene.entry_page(),
1831        ) {
1832            Ok(e) => e,
1833            Err(_) => panic!("q42 http bind"),
1834        };
1835        let range = InclusiveRange::from_start_length(0, take as u64).unwrap();
1836        let mut owner = AuthorityOwner::new();
1837        let mut grant =
1838            adopt_local_whole_source(&mut owner, &pins, &bound, scene.request()).unwrap();
1839        let mut ledger = ledger();
1840        let mut window = vec![0u8; take];
1841        let mut full_out = vec![0u8; q42.len()];
1842        let mut served_status = 0u16;
1843        let mut served_len = 0usize;
1844        let mut served_etag = [0u8; 98];
1845        let mut served_etag_len = 0usize;
1846        let mut served_cr = [0u8; 80];
1847        let mut served_cr_len = 0usize;
1848        let mut full_status = 0u16;
1849        let mut full_len = 0usize;
1850        match grant.accept_local_scoped(&pins, || 20, |authority| {
1851            Ok((|| -> Result<(), ProviderError> {
1852                let served = bound_entry.provider.serve(
1853                    HttpObject::Representation,
1854                    Some(range),
1855                    None,
1856                    Validator::NONE,
1857                    ServeOptions {
1858                        fallback: FallbackPolicy::FORBIDDEN,
1859                        verified_peer: true,
1860                    },
1861                    authority,
1862                    &mut ledger,
1863                    &mut window,
1864                )?;
1865                if served.status != 206 {
1866                    return Err(ProviderError::Unsatisfiable);
1867                }
1868                served_status = served.status;
1869                served_len = served.body_len;
1870                served_etag = served.headers.etag;
1871                served_etag_len = served.headers.etag_len;
1872                served_cr = served.headers.content_range;
1873                served_cr_len = served.headers.content_range_len;
1874                match validate_exact_range_response(
1875                    Q42ByteRange {
1876                        offset: 0,
1877                        length: take,
1878                    },
1879                    q42.len() as u64,
1880                    range.start(),
1881                    served.body_len,
1882                ) {
1883                    Ok(()) => {}
1884                    Err(_) => return Err(ProviderError::Unsatisfiable),
1885                }
1886                let fallback = match FallbackPolicy::explicit(LEGACY_FULL_OBJECT_FALLBACK_BYTES) {
1887                    Ok(p) => p,
1888                    Err(e) => return Err(ProviderError::Status(e)),
1889                };
1890                let full = bound_entry.provider.serve(
1891                    HttpObject::Representation,
1892                    None,
1893                    None,
1894                    Validator::NONE,
1895                    ServeOptions {
1896                        fallback,
1897                        verified_peer: true,
1898                    },
1899                    authority,
1900                    &mut ledger,
1901                    &mut full_out,
1902                )?;
1903                if full.status != 200 {
1904                    return Err(ProviderError::Unsatisfiable);
1905                }
1906                full_status = full.status;
1907                full_len = full.body_len;
1908                Ok(())
1909            })())
1910        }) {
1911            Ok(Ok(())) => {}
1912            Ok(Err(_)) => panic!("q42 http range provider"),
1913            Err(_) => panic!("q42 http range grant"),
1914        }
1915        assert_eq!(served_status, 206);
1916        assert_eq!(&window[..served_len], native_window.as_slice());
1917        assert_eq!(full_status, 200);
1918        assert_eq!(&full_out[..full_len], q42.as_slice());
1919
1920        let mut cr = [0u8; 80];
1921        let cn = write_content_range(range, q42.len() as u64, &mut cr).unwrap();
1922        assert_eq!(&served_cr[..served_cr_len], &cr[..cn]);
1923        let etag_s = std::str::from_utf8(&served_etag[..served_etag_len])
1924            .unwrap()
1925            .to_string();
1926        let (addr, captured, th) = spawn_http(
1927            served_status,
1928            vec![
1929                (
1930                    "Content-Range".into(),
1931                    String::from_utf8_lossy(&cr[..cn]).into_owned(),
1932                ),
1933                ("Content-Length".into(), take.to_string()),
1934                ("Content-Encoding".into(), "identity".into()),
1935                ("ETag".into(), etag_s),
1936            ],
1937            native_window.clone(),
1938        );
1939        let host = format!("{addr}").into_bytes();
1940        let req = RangeRequest {
1941            host: &host,
1942            path: b"/objects/mixed/representations/40",
1943            range,
1944            pinned_total: q42.len() as u64,
1945            if_range: Some(&served_etag[..served_etag_len]),
1946            expected: Validator {
1947                etag: Some(&served_etag[..served_etag_len]),
1948                last_modified: None,
1949            },
1950            fallback: FallbackPolicy::FORBIDDEN,
1951            budget: FetchBudget {
1952                max_body: LEGACY_FULL_OBJECT_FALLBACK_BYTES,
1953                max_headers: HEADER_CAP,
1954            },
1955            lig: LigGate::consented_active(),
1956        };
1957        let mut stream = connect(addr);
1958        let mut client_out = vec![0u8; take];
1959        let got = match get_range(&mut stream, &req, &mut client_out) {
1960            Ok(v) => v,
1961            Err(_) => panic!("hostile q42 loopback must return the authenticated window"),
1962        };
1963        assert_eq!(
1964            got,
1965            Fetched::Partial {
1966                length: take
1967            }
1968        );
1969        assert_eq!(&client_out[..take], native_window.as_slice());
1970        let text = String::from_utf8_lossy(&captured.lock().unwrap()).into_owned();
1971        assert!(text.contains("Accept-Encoding: identity"));
1972        assert!(text.contains("Range: bytes="));
1973        assert!(!text.contains("Authorization:"));
1974        th.join().unwrap();
1975    }
1976}