Struct SqliteRegistryAssembly 

pub struct SqliteRegistryAssembly { /* private fields */ }

The sqlite twin assembly — the pieces one adapter constructor wires over the default engine assembly (single-host shape, substrate.md §assembly: alkstore-sqlite + the co-tenant twin on one file):

• SqliteRegistryAssembly::store — the opened alkstore engine handle (the reactive halves’ substrate).
• SqliteRegistryAssembly::write — the announced write side (AnnouncingRegistry): the pair with the post-commit announce wired by default (ADR-019 §5 — no non-reactive shipped path).
• SqliteRegistryAssembly::durable — the bare twin (announce free — the probe legs run here).
• SqliteRegistryAssembly::provider — the cached read provider, loaded once from the durable side at construction (loud — a registry serving an empty snapshot over a populated table would contradict the definite-miss read contract).
• SqliteRegistryAssembly::reactor — the wake runner/stream consumer/reconcile machinery, holding the durable side.
• SqliteRegistryAssembly::refs — the refs row CAS over the same co-tenant handle, write-counter-wrapped (VersionedRefTable; the seeded HEAD row is its unborn shape) — the counter SqliteRegistryAssembly::refs_version exposes is the liveness source’s arbitration-window signal.
• SqliteRegistryAssembly::backend — the core-traits binding (RegistryBackend::with_cached_provider) over the announced write side: the store methods announce post-commit and write through.
• SqliteRegistryAssembly::lfs_rows — the LFS pointer-lifecycle row CAS over the same co-tenant handle, write-counter-wrapped (VersionedLfsRows — the refs-twins’ wrap posture; the composition entry composes it unchanged) — the counter SqliteRegistryAssembly::lfs_version exposes is the LFS liveness source’s arbitration-window signal.

The wave-8 single composition entry unifies construction; this is the per-piece constructor (the recorded interpretation, flagged for the gate).

Implementations

impl SqliteRegistryAssembly

pub async fn open(path: impl AsRef<Path>) -> Result<Self, OpenError>

The adapter constructor: open the co-tenant connection at path (migrations at construction, loud — a half-migrated store refuses service; :memory: confers no co-tenancy and is rejected before the engine opens), open the alkstore-sqlite engine at the same path, load the provider’s initial snapshot, and wire the reactive composition. Every failure is OpenError.

pub fn store(&self) -> &Arc<dyn Store>

The opened alkstore engine handle (the reactive halves’ substrate; the wave-7 maintenance chain rides the same).

pub fn write(&self) -> &Arc<dyn RegistryWrite>

The announced write side — the pair with the post-commit announce wired (the write surface the composition’s callers use).

pub fn durable(&self) -> &Arc<SqliteRegistry>

The bare twin (announce-free — the transactional legs’ probe surface).

pub fn provider(&self) -> &Arc<CachedRegistryProvider>

The cached read provider (the hot read).

pub fn reactor(&self) -> &Arc<Reactor>

The reactor (the wake runner / stream consumer / reconcile sweep run through it).

pub fn refs(&self) -> &Arc<VersionedRefTable<SqliteRefTable>>

The refs row CAS over the same co-tenant handle — the write-counter-wrapped composition refs (VersionedRefTable): the CAS semantics are unchanged (verbatim delegation), every CAS call bumps the shared counter the liveness source’s arbitration consult reads (crate::liveness — the composition’s invalidation half). Pushes route through this impl.

pub fn refs_version(&self) -> &Arc<AtomicU64>

The refs writes’ shared counter — the same handle Self::refs bumps and the crate::liveness::RefClosure source consults; hand it to the closure’s constructor.

pub fn backend(&self) -> &Arc<RegistryBackend>

The core-traits binding (the engine-twin binding announced and write-through wired).

pub fn lfs_rows(&self) -> &Arc<VersionedLfsRows<SqliteLfsRows>>

The LFS pointer-lifecycle row CAS over the same co-tenant handle — the write-counter-wrapped rows (crate::lfs::VersionedLfsRows; the refs twins’ wrap posture, the per-piece parity posture the per-piece-path embedder composes): the row semantics are unchanged (verbatim delegation), every assert bumps the shared counter the LFS liveness source’s arbitration consult reads (crate::liveness — the composition’s invalidation half). The record-removal leg takes a removed repo’s rows with the record transactionally (the twins’ unconditional in-SQL copy).

pub fn lfs_version(&self) -> &Arc<AtomicU64>

The LFS rows’ asserts’ shared counter — the same handle Self::lfs_rows bumps and the crate::liveness::LfsMedia source consults; hand it to the media source’s constructor.