Skip to content

vox-db API Reference (generated)

Crate: vox-db · Version: 0.6.0 · Target: Library (lib.rs)

Codex / VoxDb facade: schema migrations, store ops, Turso/libSQL access for the Vox workspace.

vox-db — High-level database facade for Vox

Section titled “vox-db — High-level database facade for Vox”

Provides a unified API over Turso/libSQL for packages, code artifacts, agent memory, Codex reactivity, and related tables. Prefer this crate over talking to turso::Connection directly in application code.

NameWhat it is
[VoxDb]Stable Rust type for this facade; use it in signatures and tests.
[Codex]Type alias for VoxDb — same type, product-facing name in docs/UI.
ArcaInternal name for schema + SQL owned by this crate (crates/vox-db/src/schema/).
vox-packagePackage registry / artifacts — not the SQL schema SSOT.

Use [VoxDb::store] (async method) for content-addressed blob writes (ops_cas); it is not a getter.

  • Remote (Turso cloud) — always available
  • Local (file-based Turso) — local feature (default)
  • In-memory — DbConfig::Memory, tests only (local feature)
  • Embedded replica (local + cloud sync) — replication feature

User-global relational data uses [DbConfig::resolve_canonical] / [canonical_store::resolve_canonical_config]. Repo-backed interactive surfaces default to the workspace journey store (.vox/store.db) via [workspace_journey_store::connect_workspace_journey_optional]; set VOX_WORKSPACE_JOURNEY_STORE=canonical for legacy user-global / Turso. See [canonical_store] and [workspace_journey_store].

Built-in and app-supplied migrations run through [turso::Connection::execute_batch], which uses execute and fails on statements that return rows (e.g. bare SELECT, assignment PRAGMA unless handled with pragma_update). [VoxDb::connect] / [VoxDb::open] apply pragmas via pragma_update and skip empty migration bodies; see also [VoxDb::apply_migrations].

use vox_db::{VoxDb, DbConfig};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let db = VoxDb::connect(DbConfig::Remote {
url: "turso://my-db.turso.io".to_string(),
token: "my-token".to_string(),
}).await?;
let hash = db.store("fn", b"fn hello(): return 42").await?;
println!("Stored: {hash}");
Ok(())
}
FeatureDefault / Enables
defaultlocal
host-integrationdep:keyring, dep:vox-config, dep:vox-repository, dep:vox-secrets
legacy-importquarantine
local—
quarantine—
replication—
test-support—
DependencyKind
vox-astNormal
vox-configNormal
vox-db-typesNormal
vox-mesh-typesNormal
vox-orchestrator-typesNormal
vox-plugin-typesNormal
vox-repositoryNormal
vox-secretsNormal
vox-telemetryNormal
vox-test-harnessDevelopment
ModuleDescription
auto_migrateCompare live SQLite schema to @table / collection declarations; non-destructive migrations.
benchmark_telemetryBenchmark observations stored in research_metrics (bench:<repository_id> sessions).
build_hints—
capabilitiesTurso / search tuning helpers (VOX_EMBEDDING_SEARCH_CANDIDATE_MULT, etc.).
circuit_breakerCircuit breaker for write operations.
codex_chatUser chat, tool calls, usage limits, topics (manifest chat/search slices).
connect_policyCanonical connect policy helpers (strict vs optional degraded surfaces).
history_store—
legacyExplicit namespace for migration-era and cutover-only pathways.
redact—
research_metrics_contractLudus / extended gamify_* contracts and metrics keys (DDL in baseline schema/domains).
schema—
schema_extensionsIdempotent schema extensions (FTS).
storeLegacy import/export planning and verification for greenfield Codex releases.
telemetry_sink—
canonical_storeCanonical Codex storage policy (vox.db vs project store vs training sidecar).
codex_legacy—
codex_schemaManifest-derived readiness (baseline digest, required tables).
collection—
data_flow—
ddl—
error_enrichment—
exec_time_telemetry—
sql_util—
learning—
legacy_import_extras—
memoryParameters for [VoxDb::store_memory]. Alias of [crate::store::SaveMemoryParams] so application code can depend on vox-db only.
migrationDeclarative SQL migrations using the schema_version table (see crate::schema).
normalizeSQL normalization and content-addressable hashing.
writer_actorData directory and per-user id helpers (delegates to vox_config).
paths—
pool—
outcome_recorder—
populi_control_telemetryMens control-plane audit (populi_control_event in research_metrics).
populi_registry_telemetryOpt-in mens local-registry publish rows (VOX_MESH_CODEX_TELEMETRY).
preferencesRegistry-scoped user preferences (stored as JSON in the local config directory).
project_store—
research_doc_io—
research_pipeline—
schema_digestAST → [crate::SchemaDigest] for LLM context and codegen.
secretsOS keyring helpers for API tokens and similar secrets.
syntax_k_telemetry—
temporal_claims—
toestub_store—
training_runMens QLoRA training run persistence (CRUD for populi_training_run table).
trialsResearch Trial Tier-A atomic persistence (STORE-01, STORE-02).
types—
workflow_journalInterpreted workflow journal (workflow_journal_entry in research_metrics).
workspace_journey_storeWorkspace journey store resolution (.vox/store.db vs canonical) for repo-backed MCP/daemon flows.
mesh_exec_leases—
mesh_locks—
oratio_eval—
plugin_state_backend—
web_cacheContent-addressed local web cache with HTTP 304 support.
facade—
StructDescription
VoxDbHigh-level database facade for the Vox ecosystem (Codex). Owns a single [VoxDb] (one Turso connection). Higher-level helpers (memory, learner, schema sync) delegate to that store; advanced callers use [Self::store] for direct access. Concurrency: one connection per VoxDb handle; Sync/safe across concurrent callers because [GuardedConnection] serializes access to the shared turso::Connection (see its docs for why this is required even though VoxDb/Connection are Clone).
GuardedConnectionSerializes access to a shared turso::Connection to avoid turso::Error::Misuse("concurrent use forbidden"). ## Root cause this fixes turso::Connection::clone() does not create an independent connection: it clones an Arc to the same underlying turso_sdk_kit::rsapi::TursoConnection, which itself guards every step() (the primitive under query/execute/execute_batch/prepare) with an atomic ConcurrentGuard. Two async tasks that call into any clones of the same connection at literally the same instant (e.g. two Tauri GUI commands dispatched close together on a multi-threaded Tokio runtime, or a background poll racing a user action) can have their step() polls genuinely overlap on different OS threads, tripping that guard and returning Err(Misuse("concurrent use forbidden")). Since VoxDb is Clone and is shared as one Arc<VoxDb> across all GUI commands (see vox-gui/src/commands/gui_db_pool.rs), this happened routinely under ordinary concurrent chat usage, and the resulting error surfaced to users as a “Message not saved” toast — the write silently never reached the database. ## Fix Hold a tokio::sync::Mutex<()> around each real network/IO-bearing call (query/execute/execute_batch/pragma_update) before delegating to the wrapped turso::Connection. The lock lives behind an Arc so every clone of a GuardedConnection (and every clone of the owning VoxDb) shares the same lock — matching the fact that they already share the same underlying Turso connection. Implements [std::ops::Deref] to turso::Connection so call sites that need a raw &turso::Connection (e.g. [crate::auto_migrate::AutoMigrator::new], schema migrations run once at connect time) keep compiling unchanged via deref coercion. Method resolution prefers inherent methods on GuardedConnection over ones reached through Deref, so the ~400 existing call sites across this crate (and the many downstream crates that call VoxDb::connection(), e.g. vox-gamify, vox-populi, vox-sql, generated vox-codegen output) that do conn.query(..) / conn.execute(..) / conn.execute_batch(..) get the lock automatically without any call-site changes. ## Known residual gap turso::Connection::last_insert_rowid() is a synchronous, non-blocking read of connection-local state and does not go through ConcurrentGuard at all (confirmed by reading turso-0.6.1’s source), so it is intentionally left un-guarded here — wrapping it would require holding the lock across the execute + last_insert_rowid pair (a call-site change) rather than per-call. Callers that do this pairing (e.g. codex_chat.rs::chat_ensure_workspace_conversation) are not actually safe from this crate’s concurrency bug class: on the multi-threaded Tokio runtime this crate runs under, a different task on a different OS thread can execute its own guarded execute() (acquiring and releasing the lock) between this caller’s execute() and its last_insert_rowid() read, since nothing holds the lock across that gap — no explicit .await yield is required for that interleaving. This does not reproduce the Misuse("concurrent use forbidden") bug this type fixes (the two individual calls are each correctly guarded), but it can silently return the other task’s row id. It is noted here as a narrower, pre-existing (not introduced by this change) correctness edge case for future hardening (e.g. INSERT ... RETURNING).
GuardedRowsRows fully drained from [GuardedConnection::query] while its mutex guard was held, so nothing about iterating this value can race (or deadlock against) another guarded call on the same [GuardedConnection] — see the guard-lifetime note on query for why a lazy, still-locked cursor isn’t safe here.
EnumDescription
ReadConsistencyWhether to pull embedded-replica updates before application-level reads.
FunctionDescription
in_memoryConnect to an ephemeral in-memory database for testing.
in_memoryConnect to an ephemeral in-memory database for testing.
queryGuarded [turso::Connection::query]. Returns [GuardedRows] rather than a bare turso::Rows. The bare cursor is lazy, so a guard dropped when this function returns (before the caller reads a single row) would let row-streaming race other tasks’ execute/query on the same connection. Holding the guard on the returned value instead (rather than only inside this function) is not an option either: tokio::sync::Mutex isn’t reentrant, and this crate’s callers routinely do let mut rows = conn.query(...).await?; then, later in the same scope, another guarded call on conn (e.g. claim_skill_identity’s SELECT-then-INSERT) — rows would still be lexically alive at that point (Rust drops locals at end of scope, not at last use), so a guard tied to it would self-deadlock. Instead, drain every row into an owned buffer while still holding the guard, then release it before returning — the lock covers the entire real connection access and nothing outlives this function.
executeGuarded [turso::Connection::execute].
execute_batchGuarded [turso::Connection::execute_batch].
pragma_updateGuarded [turso::Connection::pragma_update].
transactionExecute an async closure inside a serialized SQLite BEGIN IMMEDIATE ... COMMIT transaction while holding the [GuardedConnection] mutex for the entire transaction lifetime. On any error returned by f, issues ROLLBACK before releasing the mutex.
nextMirrors [turso::Rows::next]‘s signature (async fn returning a Result) purely so existing rows.next().await? call sites keep compiling unchanged; the buffer is already fully materialized, so this never actually awaits or errors.
TypeDescription
MemoryParams—
CodexPublic product name for the unified database facade (Codex over Arca/Turso). VoxDb remains the stable Rust type name; new documentation should prefer Codex.
Dependency Topology, diagram 123 nodes, 22 edges: vox-db → vox-ast; vox-db → vox-config; vox-db → vox-db-types; vox-db → vox-mesh-types; vox-db → vox-orchestrator-types; vox-db → vox-plugin-types; vox-db → vox-repository; vox-db → vox-secrets; vox-db → vox-telemetry; vox-db → vox-test-harness; vox-actor-runtime → vox-db; vox-cl…vox-dbvox-astvox-configvox-db-typesvox-mesh-typesvox-orchestrator-typesvox-plugin-typesvox-repositoryvox-secretsvox-telemetryvox-test-harnessvox-actor-runtimevox-clivox-cli-civox-cli-corevox-cli-researchvox-cli-reviewvox-codegenvox-corpusvox-gamifyvox-guivox-ml-clivox-openclaw-runtime
Diagram source
graph {
direction: right
node vox_db: "vox-db"
node vox_ast: "vox-ast"
vox_db -> vox_ast
node vox_config: "vox-config"
vox_db -> vox_config
node vox_db_types: "vox-db-types"
vox_db -> vox_db_types
node vox_mesh_types: "vox-mesh-types"
vox_db -> vox_mesh_types
node vox_orchestrator_types: "vox-orchestrator-types"
vox_db -> vox_orchestrator_types
node vox_plugin_types: "vox-plugin-types"
vox_db -> vox_plugin_types
node vox_repository: "vox-repository"
vox_db -> vox_repository
node vox_secrets: "vox-secrets"
vox_db -> vox_secrets
node vox_telemetry: "vox-telemetry"
vox_db -> vox_telemetry
node vox_test_harness: "vox-test-harness"
vox_db -> vox_test_harness
node vox_actor_runtime: "vox-actor-runtime"
vox_actor_runtime -> vox_db
node vox_cli: "vox-cli"
vox_cli -> vox_db
node vox_cli_ci: "vox-cli-ci"
vox_cli_ci -> vox_db
node vox_cli_core: "vox-cli-core"
vox_cli_core -> vox_db
node vox_cli_research: "vox-cli-research"
vox_cli_research -> vox_db
node vox_cli_review: "vox-cli-review"
vox_cli_review -> vox_db
node vox_codegen: "vox-codegen"
vox_codegen -> vox_db
node vox_corpus: "vox-corpus"
vox_corpus -> vox_db
node vox_gamify: "vox-gamify"
vox_gamify -> vox_db
node vox_gui: "vox-gui"
vox_gui -> vox_db
node vox_ml_cli: "vox-ml-cli"
vox_ml_cli -> vox_db
node vox_openclaw_runtime: "vox-openclaw-runtime"
vox_openclaw_runtime -> vox_db
}
Consumer CrateRole
vox-actor-runtimeDirect workspace dependent
vox-cliDirect workspace dependent
vox-cli-ciDirect workspace dependent
vox-cli-coreDirect workspace dependent
vox-cli-researchDirect workspace dependent
vox-cli-reviewDirect workspace dependent
vox-codegenDirect workspace dependent
vox-corpusDirect workspace dependent
vox-gamifyDirect workspace dependent
vox-guiDirect workspace dependent
vox-ml-cliDirect workspace dependent
vox-openclaw-runtimeDirect workspace dependent
vox-orchestratorDirect workspace dependent
vox-orchestrator-dDirect workspace dependent
vox-orchestrator-mcpDirect workspace dependent
vox-orchestrator-modelsDirect workspace dependent
vox-orchestrator-queueDirect workspace dependent
vox-packageDirect workspace dependent
vox-plugin-mens-candle-coreDirect workspace dependent
vox-plugin-populi-meshDirect workspace dependent
vox-plugin-publicationDirect workspace dependent
vox-populiDirect workspace dependent
vox-publisherDirect workspace dependent
vox-research-shimDirect workspace dependent
vox-scientiaDirect workspace dependent
vox-searchDirect workspace dependent
vox-skillsDirect workspace dependent
vox-sqlDirect workspace dependent
vox-workflow-runtimeDirect workspace dependent
KindSymbolSignatureSourceDescription
typeMemoryParamspub type MemoryParams<'a> = crate::store::SaveMemoryParams<'a>crates/vox-db/src/lib.rs#L120—
typeCodexpub type Codex = VoxDbcrates/vox-db/src/lib.rs#L299Public product name for the unified database facade (Codex over Arca/Turso). VoxDb remains the stable Rust type name; new documentation should prefer Codex.
enumReadConsistencypub enum ReadConsistencycrates/vox-db/src/lib.rs#L303-L308Whether to pull embedded-replica updates before application-level reads.
structVoxDbpub struct VoxDbcrates/vox-db/src/lib.rs#L319-L331High-level database facade for the Vox ecosystem (Codex). Owns a single [VoxDb] (one Turso connection). Higher-level helpers (memory, learner, schema sync) delegate to that store; advanced callers use [Self::store] for direct access. Concurrency: one connection per VoxDb handle; Sync/safe across concurrent callers because [GuardedConnection] serializes access to the shared turso::Connection (see its docs for why this is required even though VoxDb/Connection are Clone).
fnin_memorypub async fn in_memory() -> Result<Self, StoreError>crates/vox-db/src/lib.rs#L351-L353Connect to an ephemeral in-memory database for testing.
fnin_memorypub async fn in_memory() -> Result<Self, StoreError>crates/vox-db/src/lib.rs#L357-L361Connect to an ephemeral in-memory database for testing.
structGuardedConnectionpub struct GuardedConnectioncrates/vox-db/src/lib.rs#L415-L418Serializes access to a shared turso::Connection to avoid turso::Error::Misuse("concurrent use forbidden"). ## Root cause this fixes turso::Connection::clone() does not create an independent connection: it clones an Arc to the same underlying turso_sdk_kit::rsapi::TursoConnection, which itself guards every step() (the primitive under query/execute/execute_batch/prepare) with an atomic ConcurrentGuard. Two async tasks that call into any clones of the same connection at literally the same instant (e.g. two Tauri GUI commands dispatched close together on a multi-threaded Tokio runtime, or a background poll racing a user action) can have their step() polls genuinely overlap on different OS threads, tripping that guard and returning Err(Misuse("concurrent use forbidden")). Since VoxDb is Clone and is shared as one Arc<VoxDb> across all GUI commands (see vox-gui/src/commands/gui_db_pool.rs), this happened routinely under ordinary concurrent chat usage, and the resulting error surfaced to users as a “Message not saved” toast — the write silently never reached the database. ## Fix Hold a tokio::sync::Mutex<()> around each real network/IO-bearing call (query/execute/execute_batch/pragma_update) before delegating to the wrapped turso::Connection. The lock lives behind an Arc so every clone of a GuardedConnection (and every clone of the owning VoxDb) shares the same lock — matching the fact that they already share the same underlying Turso connection. Implements [std::ops::Deref] to turso::Connection so call sites that need a raw &turso::Connection (e.g. [crate::auto_migrate::AutoMigrator::new], schema migrations run once at connect time) keep compiling unchanged via deref coercion. Method resolution prefers inherent methods on GuardedConnection over ones reached through Deref, so the ~400 existing call sites across this crate (and the many downstream crates that call VoxDb::connection(), e.g. vox-gamify, vox-populi, vox-sql, generated vox-codegen output) that do conn.query(..) / conn.execute(..) / conn.execute_batch(..) get the lock automatically without any call-site changes. ## Known residual gap turso::Connection::last_insert_rowid() is a synchronous, non-blocking read of connection-local state and does not go through ConcurrentGuard at all (confirmed by reading turso-0.6.1’s source), so it is intentionally left un-guarded here — wrapping it would require holding the lock across the execute + last_insert_rowid pair (a call-site change) rather than per-call. Callers that do this pairing (e.g. codex_chat.rs::chat_ensure_workspace_conversation) are not actually safe from this crate’s concurrency bug class: on the multi-threaded Tokio runtime this crate runs under, a different task on a different OS thread can execute its own guarded execute() (acquiring and releasing the lock) between this caller’s execute() and its last_insert_rowid() read, since nothing holds the lock across that gap — no explicit .await yield is required for that interleaving. This does not reproduce the Misuse("concurrent use forbidden") bug this type fixes (the two individual calls are each correctly guarded), but it can silently return the other task’s row id. It is noted here as a narrower, pre-existing (not introduced by this change) correctness edge case for future hardening (e.g. INSERT ... RETURNING).
fnquerypub async fn query(crates/vox-db/src/lib.rs#L442Guarded [turso::Connection::query]. Returns [GuardedRows] rather than a bare turso::Rows. The bare cursor is lazy, so a guard dropped when this function returns (before the caller reads a single row) would let row-streaming race other tasks’ execute/query on the same connection. Holding the guard on the returned value instead (rather than only inside this function) is not an option either: tokio::sync::Mutex isn’t reentrant, and this crate’s callers routinely do let mut rows = conn.query(...).await?; then, later in the same scope, another guarded call on conn (e.g. claim_skill_identity’s SELECT-then-INSERT) — rows would still be lexically alive at that point (Rust drops locals at end of scope, not at last use), so a guard tied to it would self-deadlock. Instead, drain every row into an owned buffer while still holding the guard, then release it before returning — the lock covers the entire real connection access and nothing outlives this function.
fnexecutepub async fn execute(crates/vox-db/src/lib.rs#L460Guarded [turso::Connection::execute].
fnexecute_batchpub async fn execute_batch(&self, sql: impl AsRef<str>) -> turso::Result<()>crates/vox-db/src/lib.rs#L471-L474Guarded [turso::Connection::execute_batch].
fnpragma_updatepub async fn pragma_update<V: std::fmt::Display>(crates/vox-db/src/lib.rs#L478Guarded [turso::Connection::pragma_update].
fntransactionpub async fn transaction<'a, F, Fut, T>(&'a self, f: F) -> Result<T, crate::StoreError>crates/vox-db/src/lib.rs#L490Execute an async closure inside a serialized SQLite BEGIN IMMEDIATE ... COMMIT transaction while holding the [GuardedConnection] mutex for the entire transaction lifetime. On any error returned by f, issues ROLLBACK before releasing the mutex.
structGuardedRowspub struct GuardedRowscrates/vox-db/src/lib.rs#L525-L527Rows fully drained from [GuardedConnection::query] while its mutex guard was held, so nothing about iterating this value can race (or deadlock against) another guarded call on the same [GuardedConnection] — see the guard-lifetime note on query for why a lazy, still-locked cursor isn’t safe here.
fnnextpub async fn next(&mut self) -> turso::Result<Option<turso::Row>>crates/vox-db/src/lib.rs#L534-L536Mirrors [turso::Rows::next]‘s signature (async fn returning a Result) purely so existing rows.next().await? call sites keep compiling unchanged; the buffer is already fully materialized, so this never actually awaits or errors.
structauto_migrate::LiveColumnpub struct LiveColumncrates/vox-db/src/auto_migrate.rs#L31-L42A column definition as read from PRAGMA table_info(...).
structauto_migrate::LiveTablepub struct LiveTablecrates/vox-db/src/auto_migrate.rs#L46-L51A table definition as introspected from the live database.
enumauto_migrate::MigrationActionpub enum MigrationActioncrates/vox-db/src/auto_migrate.rs#L57-L96A single migration action to be applied.
fnauto_migrate::is_auto_safepub fn is_auto_safe(&self) -> boolcrates/vox-db/src/auto_migrate.rs#L100-L108Returns true if this action is safe to apply automatically.
fnauto_migrate::to_sqlpub fn to_sql(&self) -> Option<String>crates/vox-db/src/auto_migrate.rs#L111-L127Generate SQL for this action. Returns None for manual-only actions.
fnauto_migrate::describepub fn describe(&self) -> Stringcrates/vox-db/src/auto_migrate.rs#L130-L149Human-readable description of this action.
structauto_migrate::MigrationPlanpub struct MigrationPlancrates/vox-db/src/auto_migrate.rs#L154-L157Result of comparing live DB state to desired declarations.
fnauto_migrate::is_emptypub fn is_empty(&self) -> boolcrates/vox-db/src/auto_migrate.rs#L161-L163Returns true if no changes are needed.
fnauto_migrate::auto_actionspub fn auto_actions(&self) -> Vec<&MigrationAction>crates/vox-db/src/auto_migrate.rs#L166-L168Actions that are safe to apply automatically.
fnauto_migrate::manual_actionspub fn manual_actions(&self) -> Vec<&MigrationAction>crates/vox-db/src/auto_migrate.rs#L171-L173Actions that require manual intervention.
fnauto_migrate::describepub fn describe(&self) -> Stringcrates/vox-db/src/auto_migrate.rs#L176-L190Generate a human-readable summary of the migration plan.
structauto_migrate::AutoMigratorpub struct AutoMigrator<'a>crates/vox-db/src/auto_migrate.rs#L194-L196Compares AST-backed declarations to PRAGMA/sqlite_master state.
fnauto_migrate::newpub fn new(conn: &'a Connection) -> Selfcrates/vox-db/src/auto_migrate.rs#L202-L204Create an engine bound to one Turso connection (typically from VoxDb / VoxDb).
fnauto_migrate::introspect_tablespub async fn introspect_tables(&self) -> Result<Vec<LiveTable>, turso::Error>crates/vox-db/src/auto_migrate.rs#L207-L249Introspect the live database to get all user tables.
fnauto_migrate::planpub async fn plan(crates/vox-db/src/auto_migrate.rs#L252Compute the migration plan by diffing live schema against desired tables.
fnauto_migrate::plan_from_digestpub async fn plan_from_digest(crates/vox-db/src/auto_migrate.rs#L268Like [Self::plan], but desired shape comes from a [SchemaDigest] (e.g. from codegen/LLM). Standard indexes from the digest are emitted; vector/search indexes are skipped here.
fnauto_migrate::applypub async fn apply(&self, plan: &MigrationPlan) -> Result<usize, turso::Error>crates/vox-db/src/auto_migrate.rs#L433-L442Apply all safe migration actions. Returns the number of actions applied.
fnauto_migrate::sync_schemapub async fn sync_schema(crates/vox-db/src/auto_migrate.rs#L445Plan and apply auto-safe migrations in one call.
fnauto_migrate::sync_from_digestpub async fn sync_from_digest(crates/vox-db/src/auto_migrate.rs#L457[Self::plan_from_digest] followed by [Self::apply] for auto-safe actions only.
structbenchmark_telemetry::BenchmarkEventMetapub struct BenchmarkEventMetacrates/vox-db/src/benchmark_telemetry.rs#L14-L26Payload for one benchmark observation.
fnbenchmark_telemetry::record_benchmark_eventpub async fn record_benchmark_event(crates/vox-db/src/benchmark_telemetry.rs#L30Append one benchmark row to research_metrics under bench:<repository_id>.
structbuild_hints::BuildHintpub struct BuildHintcrates/vox-db/src/build_hints.rs#L8-L15One entry in the static hint table.
fnbuild_hints::lookup_hintpub fn lookup_hint(crate_name: &str, warning_code: Option<&str>) -> Option<&'static str>crates/vox-db/src/build_hints.rs#L80-L101Return the first matching suggestion for a crate + optional warning code. Returns None when no pattern matches.
fncanonical_store::resolve_canonical_configpub fn resolve_canonical_config() -> Result<DbConfig, String>crates/vox-db/src/canonical_store.rs#L27-L29Resolves the canonical user-global [DbConfig] for Codex / VoxDB. Alias for [DbConfig::resolve_canonical]; use either name for clarity at callsites.
fncanonical_store::user_global_sqlite_pathpub fn user_global_sqlite_path() -> Option<PathBuf>crates/vox-db/src/canonical_store.rs#L33-L35Default local path to vox.db when the platform data dir is known (VOX_DATA_DIR / defaults).
structcapabilities::SqliteProbeSnapshotpub struct SqliteProbeSnapshotcrates/vox-db/src/capabilities.rs#L11-L18Observed libSQL/SQLite behavior for strategy selection (best-effort; never panics on parse).
fncapabilities::probe_sqlite_capabilitiespub async fn probe_sqlite_capabilities(crates/vox-db/src/capabilities.rs#L21Run lightweight PRAGMA probes on an open connection (safe for repeated calls).
fncapabilities::embedding_candidate_cappub fn embedding_candidate_cap(crates/vox-db/src/capabilities.rs#L64Rows to scan before ranking = limit * multiplier, capped. Override with VOX_EMBEDDING_SEARCH_CANDIDATE_MULT (integer ≥ 1). Default multiplier is passed by the caller (e.g. 10 for search_similar_embeddings). When probe reports fts5_reported == false, the effective multiplier is boosted (capped) so brute-force embedding recall stays competitive on builds without FTS5 in compile options.
enumcircuit_breaker::CircuitBreakerErrorpub enum CircuitBreakerErrorcrates/vox-db/src/circuit_breaker.rs#L43-L47Error emitted when the circuit is open.
structcircuit_breaker::DbCircuitBreakerpub struct DbCircuitBreakercrates/vox-db/src/circuit_breaker.rs#L60-L67Thread-safe circuit breaker for database write paths. Enabled only when VOX_DB_CIRCUIT_BREAKER=1 in the environment. When disabled, [DbCircuitBreaker::call] always executes the action.
fncircuit_breaker::enabled_from_envpub fn enabled_from_env() -> boolcrates/vox-db/src/circuit_breaker.rs#L78-L85Returns true when VOX_DB_CIRCUIT_BREAKER=1 (or true). Inlined rather than calling vox_config::db_circuit_breaker_env_enabled() (mirrors that function exactly): this crate’s vox-config dependency is optional behind the host-integration feature, and the circuit breaker is used by non-host-integration consumers (e.g. vox-orchestrator) that still need to read this one env var.