refactor(koinon): split the shared crate into stoicheion and tekmerion

crates/akroasis/Cargo.toml

@@ -29,7 +29,8 @@ figment = { workspace = true }
 indicatif = "0.17"
 jiff = { workspace = true }
 kerykeion = { path = "../kerykeion" }
-koinon = { path = "../koinon" }
+stoicheion = { path = "../stoicheion" }
+tekmerion = { path = "../tekmerion" }
 kryphos = { path = "../kryphos" }
 rpassword = { workspace = true }
 serde = { workspace = true }

crates/akroasis/src/caller.rs

@@ -6,14 +6,15 @@
 
 use std::fmt;
 
-use koinon::{
+use snafu::{ResultExt, Snafu};
+use stoicheion::Timestamp;
+use tekmerion::{
     AuthorizationDenial, AuthorizationRequirement, CALLER_RESOLVER_VERSION, CallerAuthority,
     CallerContractError, CallerRef, CallerResolver, EffectDescriptor, EffectOutcome, EffectReceipt,
     EffectReceiptError, EffectReceiptSink, EvidenceDigest, LocalPeerCredentials, PersistedIntent,
     PersistedOutcome, ReceiptDigest, RecoveryAuthorization, RecoveryTicket, RevocationState,
-    Timestamp, ValidatedCaller, authorize_caller,
+    ValidatedCaller, authorize_caller,
 };
-use snafu::{ResultExt, Snafu};
 use tokio::net::UnixStream;
 
 /// Version of accepted service-identity evidence.
@@ -423,19 +424,19 @@ where
 
 const fn outcome_needs_recovery(
     outcome: EffectOutcome,
-    recovery: koinon::RecoveryRelation,
+    recovery: tekmerion::RecoveryRelation,
 ) -> bool {
     matches!(
         (outcome, recovery),
         (
             EffectOutcome::Partial | EffectOutcome::RecoveryRequired,
-            koinon::RecoveryRelation::RequiredFor(_)
+            tekmerion::RecoveryRelation::RequiredFor(_)
         ) | (
             EffectOutcome::Failed
                 | EffectOutcome::Cancelled
                 | EffectOutcome::Backpressured
                 | EffectOutcome::AuthorizationDenied,
-            koinon::RecoveryRelation::RecoveryOf(_)
+            tekmerion::RecoveryRelation::RecoveryOf(_)
         )
     )
 }

crates/akroasis/src/caller_tests.rs

@@ -8,7 +8,7 @@
 use std::cell::Cell;
 use std::rc::Rc;
 
-use koinon::{
+use tekmerion::{
     AuthorityClaims, AuthorityDecision, AuthorityGrant, AuthorizationDenial,
     AuthorizationRequirement, CALLER_CONTEXT_VERSION, CallerContractError, CapabilityRef,
     PersonaRef, PolicyEpoch, PrincipalSource, ScopeRef, authorize_caller,

crates/akroasis/src/radio/export.rs

@@ -278,7 +278,7 @@ fn csv_escape(s: &str) -> String {
     reason = "test code: panics and unwraps acceptable in assertions"
 )]
 mod tests {
-    use koinon::Frequency;
+    use stoicheion::Frequency;
     use syntonia::tone::CtcssTone;
     use syntonia::types::FrequencyOffset;
 

crates/akroasis/src/radio/import.rs

@@ -3,9 +3,9 @@
 use std::io::Write;
 use std::path::Path;
 
-use koinon::Frequency;
 use serde::Serialize;
 use snafu::ResultExt;
+use stoicheion::Frequency;
 use syntonia::{Bandwidth, Channel, FrequencyPlan, PowerLevel, ScanMode, ToneMode};
 
 use super::errors::{IoSnafu, JsonReportSnafu, RadioError, ReadFileSnafu, SyntoniaSnafu};

crates/akroasis/src/radio/program.rs

@@ -128,7 +128,7 @@ pub(crate) fn load_plan(path: &Path) -> Result<FrequencyPlan, RadioError> {
     reason = "test code: panics and unwraps acceptable in assertions"
 )]
 mod tests {
-    use koinon::Frequency;
+    use stoicheion::Frequency;
     use syntonia::{Bandwidth, Channel, PowerLevel, ScanMode, ToneMode, types::FrequencyOffset};
 
     use super::*;

crates/akroasis/src/radio/read.rs

@@ -129,7 +129,7 @@ const fn format_scan(scan: ScanMode) -> &'static str {
     reason = "test code: panics and unwraps acceptable in assertions"
 )]
 mod tests {
-    use koinon::Frequency;
+    use stoicheion::Frequency;
     use syntonia::tone::CtcssTone;
     use syntonia::types::FrequencyOffset;
 

crates/akroasis/src/radio/serial_hardware.rs

@@ -1,6 +1,6 @@
 //! Feature-gated live serial radio detection and protocol session backend.
 
-use koinon::RadioKind;
+use stoicheion::RadioKind;
 use syntonia::baofeng::{
     codec::{CodecError, decode_all_channels, encode_all_channels},
     image::MemoryImage,

crates/akroasis/tests/caller_architecture.rs

@@ -90,11 +90,7 @@ fn restricted_identifiers(source: &str) -> BTreeSet<String> {
 #[test]
 fn caller_construction_aliases_are_detected() {
     let source = r"
-        use koinon::{
-            AuthorityClaimsBuilder as Claims,
-            CallerAuthority as Authority,
-            CallerResolver as Resolver,
-        };
+        use tekmerion::{AuthorityClaimsBuilder as Claims, CallerAuthority as Authority, CallerResolver as Resolver};
 
         fn bypass<A: Authority>(authority: A) {
             let _claims = Claims::new();
@@ -166,8 +162,8 @@ fn is_allowed(path: &Path) -> bool {
         || path == Path::new("crates/akroasis/tests/caller_contract.rs")
         || path == Path::new("crates/akroasis/tests/caller_recovery.rs")
         || path == Path::new("crates/akroasis/tests/caller_receipt_wire.rs")
-        || path == Path::new("crates/koinon/src/caller.rs")
-        || path == Path::new("crates/koinon/src/lib.rs")
+        || path == Path::new("crates/tekmerion/src/caller.rs")
+        || path == Path::new("crates/tekmerion/src/lib.rs")
 }
 
 fn collect_rust_files(path: &Path, files: &mut Vec<PathBuf>) {

crates/akroasis/tests/caller_contract.rs

@@ -13,14 +13,15 @@ use akroasis_lib::caller::{
     AdmissionDecision, ApplicationCallerError, ApplicationCallerResolver, EffectExecution,
     EffectGateError, EffectRequest, TrustedClock, execute_effect,
 };
-use koinon::{
+use snafu::Snafu;
+use stoicheion::Timestamp;
+use tekmerion::{
     AuthorityClaims, AuthorityDecision, AuthorityGrant, AuthorizationDenial,
     AuthorizationRequirement, CALLER_CONTEXT_VERSION, CALLER_RESOLVER_VERSION, CallerAuthority,
     CallerContractError, CallerRef, CapabilityRef, EffectDescriptor, EffectOutcome, EffectReceipt,
     EffectReceiptError, EffectReceiptSink, EffectRef, LocalPeerCredentials, PersonaRef,
-    PolicyEpoch, ReceiptDigest, ReceiptEvent, SchemaEpoch, ScopeRef, Timestamp,
+    PolicyEpoch, ReceiptDigest, ReceiptEvent, SchemaEpoch, ScopeRef,
 };
-use snafu::Snafu;
 use tokio::net::UnixStream;
 
 #[derive(Debug, Clone, Copy)]
@@ -296,7 +297,7 @@ fn standard_grant() -> AuthorityGrant {
     )
 }
 
-fn valid_caller() -> koinon::ValidatedCaller {
+fn valid_caller() -> tekmerion::ValidatedCaller {
     let authority = FakeAuthority::granted(standard_grant(), policy_epoch(7));
     let resolver = ApplicationCallerResolver::current(authority).expect("current resolver");
     let (client, _server) = UnixStream::pair().expect("Unix socket pair");

crates/akroasis/tests/caller_receipt_wire.rs

@@ -11,14 +11,14 @@ use akroasis_lib::caller::{
     AdmissionDecision, ApplicationCallerResolver, EffectExecution, EffectRequest, TrustedClock,
     execute_effect,
 };
-use koinon::{
+use snafu::Snafu;
+use stoicheion::Timestamp;
+use tekmerion::{
     AuthorityClaims, AuthorityDecision, AuthorityGrant, AuthorizationRequirement,
     CALLER_CONTEXT_VERSION, CallerAuthority, CallerRef, CapabilityRef, EffectDescriptor,
     EffectReceipt, EffectReceiptError, EffectReceiptSink, EffectRef, EvidenceDigest,
     LocalPeerCredentials, PolicyEpoch, ReceiptDigest, RecoveryRelation, SchemaEpoch, ScopeRef,
-    Timestamp,
 };
-use snafu::Snafu;
 use tokio::net::UnixStream;
 
 #[derive(Debug, Clone, Copy)]

crates/akroasis/tests/caller_recovery.rs

@@ -12,14 +12,15 @@ use akroasis_lib::caller::{
     AdmissionDecision, ApplicationCallerResolver, EffectExecution, EffectGateError, EffectRequest,
     TrustedClock, execute_effect,
 };
-use koinon::{
+use snafu::Snafu;
+use stoicheion::Timestamp;
+use tekmerion::{
     AuthorityClaims, AuthorityDecision, AuthorityGrant, AuthorizationRequirement,
     CALLER_CONTEXT_VERSION, CallerAuthority, CallerRef, CapabilityRef, EFFECT_RECEIPT_VERSION,
     EffectDescriptor, EffectOutcome, EffectReceipt, EffectReceiptError, EffectReceiptSink,
     EffectRef, LocalPeerCredentials, PersistedIntent, PersistedOutcome, PolicyEpoch, ReceiptDigest,
-    ReceiptEvent, RecoveryAuthorization, RecoveryRelation, SchemaEpoch, ScopeRef, Timestamp,
+    ReceiptEvent, RecoveryAuthorization, RecoveryRelation, SchemaEpoch, ScopeRef,
 };
-use snafu::Snafu;
 use tokio::net::UnixStream;
 
 #[derive(Debug, Clone, Copy)]
@@ -255,7 +256,7 @@ fn grant() -> AuthorityGrant {
     )
 }
 
-fn caller() -> koinon::ValidatedCaller {
+fn caller() -> tekmerion::ValidatedCaller {
     let resolver = ApplicationCallerResolver::current(RecoveryAuthority { grant: grant() })
         .expect("current caller resolver");
     let (client, _server) = UnixStream::pair().expect("Unix socket pair");

crates/kerykeion/Cargo.toml

@@ -7,7 +7,7 @@ license.workspace = true
 description = "Meshtastic mesh networking integration for Akroasis"
 
 [dependencies]
-koinon = { path = "../koinon" }
+stoicheion = { path = "../stoicheion" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 snafu = { workspace = true }

crates/kerykeion/src/collector.rs

@@ -8,7 +8,7 @@
 use std::sync::Arc;
 use std::time::Duration;
 
-use koinon::GeoSignal;
+use stoicheion::GeoSignal;
 use tokio::sync::{Mutex, broadcast};
 use tokio::task::JoinSet;
 use tokio_util::sync::CancellationToken;
@@ -37,7 +37,10 @@ use crate::types::ClaimedNodeNum;
 /// Trait for Akroasis data collectors.
 ///
 /// Defines the minimal lifecycle interface shared across all collector crates.
-/// This is a local definition pending the addition of `koinon::Collector`.
+/// This is a local definition pending a shared one. Which crate it belongs in
+/// is genuinely open: a collector produces signals, which is `stoicheion`'s
+/// layer, but it is a pipeline role rather than an element, so it may belong
+/// in neither. Left local until something forces the choice.
 pub trait Collector: Send + Sync {
     /// Returns the canonical name of this collector.
     fn name(&self) -> &'static str;

crates/kerykeion/src/discovery.rs

@@ -2,7 +2,7 @@
 
 use std::time::Duration;
 
-use koinon::GeoSignal;
+use stoicheion::GeoSignal;
 use tokio::sync::broadcast;
 use tokio_util::sync::CancellationToken;
 use tracing::instrument;