Struct AsyncProximityMap 

pub struct AsyncProximityMap<S: AsyncStore> { /* private fields */ }

Implementations

impl<S> AsyncProximityMap<S>

where S: AsyncStore + Clone, S::Error: Send + Sync,

pub async fn build( store: S, config: ProximityConfig, records: impl IntoIterator<Item = ProximityRecord>, ) -> Result<Self, Error>

Build and publish a canonical proximity map directly through AsyncStore.

pub async fn build_with_parallelism( store: S, config: ProximityConfig, records: impl IntoIterator<Item = ProximityRecord>, parallelism: BuildParallelism, ) -> Result<(Self, ProximityBuildStats), Error>

Build through AsyncStore with an explicit deterministic CPU worker limit.

pub async fn build_with_options( store: S, config: ProximityConfig, records: impl IntoIterator<Item = ProximityRecord>, options: AsyncProximityBuildOptions, ) -> Result<(Self, ProximityBuildStats), Error>

Build with explicit memory, record, CPU, and provider batch limits.

pub fn clear_content_cache(&self)

Clear retained ordered-directory nodes. Search-runtime caches are owned separately.

pub async fn read(&self) -> Result<AsyncProximityReadSession<'_, S>, Error>

pub async fn get( &self, key: &[u8], ) -> Result<Option<ExactProximityRecord>, Error>

pub async fn get_with<R>( &self, key: &[u8], read: impl for<'record> FnOnce(ProximityRecordRef<'record>) -> R, ) -> Result<Option<R>, Error>

pub async fn contains_key(&self, key: &[u8]) -> Result<bool, Error>

pub async fn scan_records( &self, visit: impl for<'record> FnMut(&[u8], ProximityRecordRef<'record>), ) -> Result<u64, Error>

pub async fn scan_records_until<B>( &self, visit: impl for<'record> FnMut(&[u8], ProximityRecordRef<'record>) -> ControlFlow<B>, ) -> Result<ScanOutcome<B>, Error>

pub async fn scan_records_range_until<B>( &self, start: &[u8], end: Option<&[u8]>, visit: impl for<'record> FnMut(&[u8], ProximityRecordRef<'record>) -> ControlFlow<B>, ) -> Result<ScanOutcome<B>, Error>

pub async fn rebuild_batch( &self, mutations: impl IntoIterator<Item = ProximityMutation>, ) -> Result<Self, Error>

Apply mutations through a clean canonical rebuild oracle.

pub async fn mutate_batch( &self, mutations: impl IntoIterator<Item = ProximityMutation>, ) -> Result<(Self, ProximityMutationStats), Error>

Canonically mutate the exact directory and rebuild derived routing only when vectors change.

pub async fn prove_membership( &self, key: &[u8], ) -> Result<ProximityMembershipProof, Error>

Prove exact presence or absence through the asynchronous directory engine.

pub async fn prove_structure( &self, limits: &ContentGraphLimits, ) -> Result<ProximityStructuralProof, Error>

Capture the authenticated typed closure through AsyncStore.

pub async fn prove_search( &self, request: SearchRequest<'_>, limits: &ContentGraphLimits, ) -> Result<ProximitySearchProof, Error>

Prove deterministic native search execution directly from an async store.

Deadline and cancellation controls are intentionally excluded because their completion point depends on wall-clock state and cannot be replayed.

pub async fn verify(&self) -> Result<ProximityVerification, Error>

Traverse and validate the async descriptor, directory, hierarchy, and routing invariants.

impl<S> AsyncProximityMap<SearchIo<S>>

where S: AsyncStore + Clone, S::Error: Send + Sync,

pub async fn load_with_runtime( store: S, descriptor: Cid, runtime: Arc<SearchRuntime>, ) -> Result<Self, Error>

Load a proximity map with a shared authenticated I/O runtime.

Decoder context is derived from the authenticated descriptor so callers cannot accidentally disable validated PRXN cache admission.

pub async fn load_with_search_io( io: SearchIo<S>, descriptor: Cid, ) -> Result<Self, Error>

Load through an existing shared-runtime binding while preserving its cache namespace and counters across map reopen operations.

pub async fn search_with_runtime( &self, request: SearchRequest<'_>, control: AsyncSearchControl, ) -> Result<SearchResult, Error>

Execute native async search with physical I/O derived from the shared runtime rather than from logical object consumption.

pub async fn search_with_accelerators( &self, accelerators: &AsyncAcceleratorSet, request: SearchRequest<'_>, control: AsyncSearchControl, ) -> Result<SearchResult, Error>

Plan and execute native, eligible-exact, PQ, or HNSW search through an async-only store using the same logical planner as synchronous search.

impl<S> AsyncProximityMap<S>

where S: AsyncStore + Clone, S::Error: Send + Sync,

pub async fn load(store: S, descriptor_cid: Cid) -> Result<Self, Error>

pub fn tree(&self) -> &ProximityTree

pub async fn search( &self, request: SearchRequest<'_>, control: AsyncSearchControl, ) -> Result<SearchResult, Error>