1use std::collections::{HashMap, HashSet, VecDeque};
2use std::sync::Arc;
3
4#[cfg(doc)]
5use khive_gate::GateRequest;
6use khive_gate::{AllowAllGate, GateRef};
7use khive_storage::EventStore;
8#[cfg(doc)]
9use khive_storage::EventView;
10use khive_types::{Namespace, NotePropertyPolicySpec};
11use serde_json::Value;
12
13use crate::error::{
14 CircularPackDependency, MissingPackDependencies, MissingPackDependency, RuntimeError,
15};
16use crate::KhiveRuntime;
17
18use super::{
19 AuditSuccessRowsMode, DispatchHook, EdgeEndpointRule, EntityTypeDef, HandlerDef,
20 PackByIdResolver, PackRuntime, VerbCategory, VerbRegistry, Visibility, RESERVED_ENVELOPE_ARGS,
21};
22#[cfg(doc)]
23use super::{PackFactory, PackRegistry};
24
25#[cfg(any(test, feature = "test-internals"))]
26type RuntimeEventStoreTestWrapper =
27 Arc<dyn Fn(Arc<dyn EventStore>) -> Arc<dyn EventStore> + Send + Sync>;
28
29pub struct VerbRegistryBuilder {
34 packs: Vec<Box<dyn PackRuntime>>,
35 pub(super) pack_versions: HashMap<String, &'static str>,
36 pack_trusted: Vec<bool>,
47 disabled_verbs: HashMap<String, Vec<String>>,
48 resolvers: Vec<(String, Box<dyn PackByIdResolver>)>,
49 pub(super) kg_read_resolver: Option<Arc<crate::kg_read::KgReadResolver>>,
50 gate: GateRef,
51 default_namespace: String,
52 visible_namespaces: Vec<Namespace>,
60 owned_namespaces: Vec<Namespace>,
67 actor_id: Option<String>,
70 event_store: Option<Arc<dyn EventStore>>,
76 runtime_event_store: Option<KhiveRuntime>,
78 #[cfg(any(test, feature = "test-internals"))]
79 test_runtime_event_store_wrapper: Option<RuntimeEventStoreTestWrapper>,
80 audit_store_read_only: bool,
83 dispatch_hook: Option<Arc<dyn DispatchHook>>,
89 audit_batch_config: Option<crate::audit_batch::AuditBatchConfig>,
93 audit_success_rows_mode: Option<AuditSuccessRowsMode>,
94}
95
96impl VerbRegistryBuilder {
97 pub fn new() -> Self {
99 Self {
100 packs: Vec::new(),
101 pack_versions: HashMap::new(),
102 pack_trusted: Vec::new(),
103 disabled_verbs: HashMap::new(),
104 resolvers: Vec::new(),
105 kg_read_resolver: None,
106 gate: std::sync::Arc::new(AllowAllGate),
107 default_namespace: Namespace::local().as_str().to_string(),
108 visible_namespaces: vec![],
109 owned_namespaces: vec![],
110 actor_id: None,
111 event_store: None,
112 runtime_event_store: None,
113 #[cfg(any(test, feature = "test-internals"))]
114 test_runtime_event_store_wrapper: None,
115 audit_store_read_only: false,
116 dispatch_hook: None,
117 audit_batch_config: None,
118 audit_success_rows_mode: None,
119 }
120 }
121
122 pub fn with_disabled_verbs(&mut self, pack: &str, verbs: &[String]) -> &mut Self {
124 self.disabled_verbs.insert(pack.to_owned(), verbs.to_vec());
125 self
126 }
127
128 pub fn with_visible_namespaces(&mut self, ns: Vec<Namespace>) -> &mut Self {
136 self.visible_namespaces = ns;
137 self
138 }
139
140 pub fn with_owned_namespaces(&mut self, ns: Vec<Namespace>) -> &mut Self {
148 self.owned_namespaces = ns;
149 self
150 }
151
152 pub fn with_actor_id(&mut self, actor_id: Option<String>) -> &mut Self {
159 self.actor_id = actor_id;
160 self
161 }
162
163 pub fn register<P: khive_types::Pack + PackRuntime + 'static>(&mut self, pack: P) -> &mut Self {
173 self.packs.push(Box::new(pack));
174 self.pack_trusted.push(false);
175 self
176 }
177
178 pub(crate) fn register_boxed(&mut self, pack: Box<dyn PackRuntime>) -> &mut Self {
191 self.packs.push(pack);
192 self.pack_trusted.push(true);
193 self
194 }
195
196 pub fn register_mounted(
198 &mut self,
199 pack: Box<dyn PackRuntime>,
200 ) -> Result<&mut Self, RuntimeError> {
201 if pack.mounted_namespace() != Some(pack.name()) || !pack.handlers().is_empty() {
202 return Err(RuntimeError::InvalidInput(
203 "invalid mounted namespace registration".into(),
204 ));
205 }
206 self.packs.push(pack);
207 self.pack_trusted.push(false);
208 Ok(self)
209 }
210
211 #[cfg(any(test, feature = "test-internals"))]
220 pub fn register_trusted<P: khive_types::Pack + PackRuntime + 'static>(
221 &mut self,
222 pack: P,
223 ) -> &mut Self {
224 self.packs.push(Box::new(pack));
225 self.pack_trusted.push(true);
226 self
227 }
228
229 pub fn register_resolver(
234 &mut self,
235 name: impl Into<String>,
236 resolver: Box<dyn PackByIdResolver>,
237 ) -> &mut Self {
238 self.resolvers.push((name.into(), resolver));
239 self
240 }
241
242 pub fn with_gate(&mut self, gate: GateRef) -> &mut Self {
248 self.gate = gate;
249 self
250 }
251
252 pub fn with_default_namespace(&mut self, ns: impl Into<String>) -> &mut Self {
257 self.default_namespace = ns.into();
258 self
259 }
260
261 pub fn with_event_store(&mut self, store: Arc<dyn EventStore>) -> &mut Self {
271 self.event_store = Some(store);
272 self.runtime_event_store = None;
273 self.audit_store_read_only = false;
274 self
275 }
276
277 pub fn with_runtime_event_store(
292 &mut self,
293 runtime: &KhiveRuntime,
294 ) -> Result<&mut Self, RuntimeError> {
295 self.event_store = None;
296 self.runtime_event_store = Some(runtime.clone());
297 self.audit_store_read_only = false;
298 Ok(self)
299 }
300
301 #[cfg(any(test, feature = "test-internals"))]
306 #[doc(hidden)]
307 pub fn with_runtime_event_store_test_wrapper<F>(&mut self, wrapper: F) -> &mut Self
308 where
309 F: Fn(Arc<dyn EventStore>) -> Arc<dyn EventStore> + Send + Sync + 'static,
310 {
311 self.test_runtime_event_store_wrapper = Some(Arc::new(wrapper));
312 self
313 }
314
315 pub fn with_audit_batch_config(
322 &mut self,
323 config: crate::audit_batch::AuditBatchConfig,
324 ) -> &mut Self {
325 self.audit_batch_config = Some(config);
326 self
327 }
328
329 pub fn with_audit_success_rows_mode(&mut self, mode: AuditSuccessRowsMode) -> &mut Self {
331 self.audit_success_rows_mode = Some(mode);
332 self
333 }
334
335 pub fn with_read_only_audit_store(&mut self) -> &mut Self {
341 self.event_store = None;
342 self.runtime_event_store = None;
343 self.audit_store_read_only = true;
344 self
345 }
346
347 pub fn with_dispatch_hook(&mut self, hook: Arc<dyn DispatchHook>) -> &mut Self {
358 self.dispatch_hook = Some(hook);
359 self
360 }
361
362 pub fn build(self) -> Result<VerbRegistry, RuntimeError> {
368 self.build_registry(true)
369 }
370
371 pub fn build_metadata(mut self) -> Result<PackMetadataRegistry, RuntimeError> {
374 self.event_store = None;
375 self.runtime_event_store = None;
376 self.dispatch_hook = None;
377 self.resolvers.clear();
378 self.build_registry(false)
379 .map(|registry| PackMetadataRegistry { registry })
380 }
381
382 fn build_registry(self, activate: bool) -> Result<VerbRegistry, RuntimeError> {
383 let packs = self.packs;
384 let mut name_to_idx: HashMap<&str, usize> = HashMap::with_capacity(packs.len());
385 for (idx, pack) in packs.iter().enumerate() {
386 if let Some(prev_idx) = name_to_idx.insert(pack.name(), idx) {
387 return Err(RuntimeError::PackRedeclared {
388 name: pack.name().to_string(),
389 first_idx: prev_idx,
390 second_idx: idx,
391 });
392 }
393 }
394
395 for mounted in packs
396 .iter()
397 .filter(|pack| pack.mounted_namespace().is_some())
398 {
399 let prefix = format!("{}.", mounted.name());
400 if packs
401 .iter()
402 .flat_map(|pack| pack.handlers())
403 .any(|handler| handler.name.starts_with(&prefix))
404 {
405 return Err(RuntimeError::InvalidInput(
406 "mounted namespace collides with a native verb".into(),
407 ));
408 }
409 }
410
411 for pack in &packs {
415 for handler in pack.handlers() {
416 for parameter in handler.params {
417 if RESERVED_ENVELOPE_ARGS.contains(¶meter.name) {
418 return Err(RuntimeError::ReservedEnvelopeParam {
419 pack: pack.name().to_string(),
420 verb: handler.name.to_string(),
421 param: parameter.name.to_string(),
422 });
423 }
424 }
425 }
426 }
427
428 let mut missing: Vec<MissingPackDependency> = Vec::new();
429 let mut indegree = vec![0usize; packs.len()];
430 let mut dependents: Vec<Vec<usize>> = vec![Vec::new(); packs.len()];
431
432 for (idx, pack) in packs.iter().enumerate() {
433 for &requires in pack.requires() {
434 match name_to_idx.get(requires).copied() {
435 Some(dep_idx) => {
436 dependents[dep_idx].push(idx);
437 indegree[idx] += 1;
438 }
439 None => missing.push(MissingPackDependency {
440 from: pack.name().to_string(),
441 requires: requires.to_string(),
442 }),
443 }
444 }
445 }
446
447 if !missing.is_empty() {
448 return if missing.len() == 1 {
449 Err(RuntimeError::MissingPackDependency(missing.remove(0)))
450 } else {
451 Err(RuntimeError::MissingPackDependencies(
452 MissingPackDependencies { missing },
453 ))
454 };
455 }
456
457 let mut ready: VecDeque<usize> = indegree
458 .iter()
459 .enumerate()
460 .filter_map(|(idx, degree)| (*degree == 0).then_some(idx))
461 .collect();
462 let mut ordered_indices = Vec::with_capacity(packs.len());
463
464 while let Some(idx) = ready.pop_front() {
465 ordered_indices.push(idx);
466 for &dep_idx in &dependents[idx] {
467 indegree[dep_idx] -= 1;
468 if indegree[dep_idx] == 0 {
469 ready.push_back(dep_idx);
470 }
471 }
472 }
473
474 if ordered_indices.len() != packs.len() {
475 let cycle_nodes: HashSet<usize> = indegree
476 .iter()
477 .enumerate()
478 .filter_map(|(idx, degree)| (*degree > 0).then_some(idx))
479 .collect();
480 let cycle = find_pack_dependency_cycle(&packs, &name_to_idx, &cycle_nodes);
481 return Err(RuntimeError::CircularPackDependency(
482 CircularPackDependency { cycle },
483 ));
484 }
485
486 let mut pack_slots: Vec<Option<Box<dyn PackRuntime>>> =
487 packs.into_iter().map(Some).collect();
488 let mut trusted_slots: Vec<Option<bool>> =
489 self.pack_trusted.into_iter().map(Some).collect();
490 let mut ordered_packs: Vec<Box<dyn PackRuntime>> = Vec::with_capacity(pack_slots.len());
491 let mut ordered_trusted: Vec<bool> = Vec::with_capacity(trusted_slots.len());
492 for idx in ordered_indices {
493 ordered_packs.push(
494 pack_slots[idx]
495 .take()
496 .expect("topological index must exist"),
497 );
498 ordered_trusted.push(
499 trusted_slots[idx]
500 .take()
501 .expect("topological index must exist"),
502 );
503 }
504
505 validate_unique_note_kinds(&ordered_packs)?;
506 validate_unique_verb_names(&ordered_packs)?;
507 validate_unique_entity_types(&ordered_packs)?;
508 validate_entity_type_note_kind_collisions(&ordered_packs)?;
509 validate_brain_consumer_kinds(&ordered_packs)?;
510 super::declaration_validation::validate_declarations(&ordered_packs)?;
511 let mut disabled_verbs = HashSet::new();
512 let mut policies: Vec<_> = self.disabled_verbs.iter().collect();
513 policies.sort_by_key(|(pack, _)| *pack);
514 for (name, verbs) in policies {
515 if verbs.is_empty() {
516 continue;
517 }
518 let pack = ordered_packs
519 .iter()
520 .find(|pack| pack.name() == name.as_str())
521 .ok_or_else(|| {
522 RuntimeError::InvalidInput(format!(
523 "packs.{name}.verbs_disabled: pack is not loaded"
524 ))
525 })?;
526 for verb in verbs {
527 let handler = pack
528 .handlers()
529 .iter()
530 .find(|handler| {
531 handler.name == verb.as_str()
532 && matches!(handler.visibility, Visibility::Verb)
533 })
534 .ok_or_else(|| {
535 RuntimeError::InvalidInput(format!(
536 "packs.{name}.verbs_disabled: {verb:?} is not a public verb owned by this pack"
537 ))
538 })?;
539 disabled_verbs.insert(handler.name);
540 }
541 }
542 let note_property_policies = collect_note_property_policies(&ordered_packs)?;
543 if activate {
544 for pack in &ordered_packs {
545 pack.validate_config()?;
546 }
547 }
548
549 let available_verbs: Vec<&'static str> = ordered_packs
550 .iter()
551 .flat_map(|p| p.handlers().iter())
552 .filter(|h| {
553 matches!(h.visibility, Visibility::Verb) && !disabled_verbs.contains(h.name)
554 })
555 .map(|h| h.name)
556 .collect();
557
558 let mut handler_by_name: HashMap<&'static str, &'static HandlerDef> = HashMap::new();
562 for pack in &ordered_packs {
563 for handler in pack.handlers() {
564 handler_by_name.entry(handler.name).or_insert(handler);
565 }
566 }
567
568 let mut audit_success_row_omitted_verbs = HashSet::new();
569 let mut audit_success_row_sampled_verbs = HashMap::new();
570 let mut success_row_owners = HashSet::new();
571 for (pack, &trusted) in ordered_packs.iter().zip(ordered_trusted.iter()) {
572 for handler in pack.handlers() {
573 if !success_row_owners.insert(handler.name) {
576 continue;
577 }
578 if trusted
579 && VerbRegistry::AUDIT_SUCCESS_ROW_OMITTED_VERBS
580 .contains(&(pack.name(), handler.name))
581 {
582 audit_success_row_omitted_verbs.insert(handler.name);
583 }
584 if let Some(&(_, _, every, forcing)) = VerbRegistry::AUDIT_SUCCESS_ROW_SAMPLED_VERBS
585 .iter()
586 .find(|&&(owner, verb, _, _)| owner == pack.name() && verb == handler.name)
587 {
588 if trusted {
589 audit_success_row_sampled_verbs.insert(handler.name, (every, forcing));
590 }
591 }
592 }
593 }
594 let audit_success_rows_mode = self
595 .audit_success_rows_mode
596 .unwrap_or_else(AuditSuccessRowsMode::from_env);
597
598 let mut degrade_safe_verbs: HashSet<&'static str> = HashSet::new();
610 let mut read_replay_safe_verbs = HashSet::new();
611 for (pack, &trusted) in ordered_packs.iter().zip(ordered_trusted.iter()) {
612 if !trusted {
613 continue;
614 }
615 let pack_name = pack.name();
616 for handler in pack.handlers() {
617 let canonical_owner = handler
618 .name
619 .split_once('.')
620 .map_or("kg", |(owner, _)| owner);
621 if matches!(handler.visibility, Visibility::Verb)
622 && pack_name == canonical_owner
623 && crate::classify_operation(handler.name) == Some(crate::OperationAccess::Read)
624 && !VerbRegistry::SIDE_EFFECTING_ASSERTIVE_VERBS.contains(&handler.name)
625 {
626 read_replay_safe_verbs.insert(handler.name);
627 }
628 if !matches!(handler.visibility, Visibility::Verb)
629 || handler.category != VerbCategory::Assertive
630 {
631 continue;
632 }
633 let eligible = VerbRegistry::admission_degrade_safe_sorted()
634 .binary_search_by(|&(p, v)| p.cmp(pack_name).then_with(|| v.cmp(handler.name)))
635 .is_ok();
636 if eligible {
637 degrade_safe_verbs.insert(handler.name);
638 }
639 }
640 }
641
642 let config_lock_runtime = self.runtime_event_store;
654 let event_store = match &config_lock_runtime {
655 Some(runtime) => Some(runtime.raw_events_for_namespace(&self.default_namespace)?),
656 None => self.event_store,
657 };
658 #[cfg(any(test, feature = "test-internals"))]
659 let event_store = match (
660 &config_lock_runtime,
661 &self.test_runtime_event_store_wrapper,
662 event_store,
663 ) {
664 (Some(_), Some(wrapper), Some(store)) => Some(wrapper(store)),
665 (_, _, store) => store,
666 };
667 if let Some(store) = &event_store {
668 if !store.supports_idempotent_audit_batch() {
669 return Err(RuntimeError::IncompatibleEventStore(
670 "the configured EventStore does not implement ADR-133's \
671 preflight_event/append_events_idempotent pair \
672 (supports_idempotent_audit_batch() returned false); every \
673 audited dispatch would silently lose its audit row while \
674 still reporting success. Implement both methods and \
675 override supports_idempotent_audit_batch() to opt in, or \
676 do not call with_event_store() for this backend."
677 .to_string(),
678 ));
679 }
680 }
681 let audit_batch = event_store.clone().map(|store| {
682 crate::audit_batch::AuditBatch::new(
683 store,
684 self.audit_batch_config.clone().unwrap_or_default(),
685 )
686 });
687
688 let attributed_edge_rules = ordered_packs
692 .iter()
693 .flat_map(|pack| {
694 pack.edge_rules()
695 .iter()
696 .map(move |rule| (pack.name().to_owned(), *rule))
697 })
698 .collect();
699
700 Ok(VerbRegistry {
701 packs: Arc::new(ordered_packs),
702 attributed_edge_rules: Arc::new(attributed_edge_rules),
703 pack_versions: Arc::new(self.pack_versions),
704 note_property_policies: Arc::new(note_property_policies),
705 resolvers: Arc::new(self.resolvers),
706 kg_read_resolver: self.kg_read_resolver,
707 gate: self.gate,
708 default_namespace: self.default_namespace,
709 visible_namespaces: self.visible_namespaces,
710 owned_namespaces: self.owned_namespaces,
711 actor_id: self.actor_id,
712 event_store,
713 config_lock_runtime,
714 audit_store_read_only: self.audit_store_read_only,
715 dispatch_hook: self.dispatch_hook,
716 available_verbs: Arc::new(available_verbs),
717 disabled_verbs: Arc::new(disabled_verbs),
718 handler_by_name: Arc::new(handler_by_name),
719 degrade_safe_verbs: Arc::new(degrade_safe_verbs),
720 audit_success_rows_mode,
721 audit_success_row_omitted_verbs: Arc::new(audit_success_row_omitted_verbs),
722 audit_success_row_sampled_verbs: Arc::new(audit_success_row_sampled_verbs),
723 read_replay_safe_verbs: Arc::new(read_replay_safe_verbs),
724 reference_ring: Arc::new(crate::reference_ring::ReferenceRing::new()),
725 audit_batch,
726 })
727 }
728}
729
730fn collect_note_property_policies(
732 packs: &[Box<dyn PackRuntime>],
733) -> Result<Vec<NotePropertyPolicySpec>, RuntimeError> {
734 let mut policies = Vec::new();
735 let mut seen = HashSet::new();
736 for pack in packs {
737 let owned_kinds = pack.note_kinds();
738 for spec in pack.note_property_policies() {
739 if !owned_kinds.contains(&spec.kind) {
740 return Err(RuntimeError::InvalidInput(format!(
741 "pack {:?} declares property policy for unowned note kind {:?}, key {:?}",
742 pack.name(),
743 spec.kind,
744 spec.key
745 )));
746 }
747 if !seen.insert((spec.kind, spec.key)) {
748 return Err(RuntimeError::InvalidInput(format!(
749 "pack {:?} declares duplicate property policy for note kind {:?}, key {:?}",
750 pack.name(),
751 spec.kind,
752 spec.key
753 )));
754 }
755 policies.push(*spec);
756 }
757 }
758 Ok(policies)
759}
760
761fn validate_unique_note_kinds(packs: &[Box<dyn PackRuntime>]) -> Result<(), RuntimeError> {
767 let mut seen: HashMap<&str, &str> = HashMap::new();
768 for pack in packs {
769 for &kind in pack.note_kinds() {
770 if let Some(first_pack) = seen.insert(kind, pack.name()) {
771 return Err(RuntimeError::InvalidInput(format!(
772 "duplicate note kind {kind:?}: claimed by both {first_pack:?} and {:?}",
773 pack.name()
774 )));
775 }
776 }
777 }
778 Ok(())
779}
780
781fn validate_brain_consumer_kinds(packs: &[Box<dyn PackRuntime>]) -> Result<(), RuntimeError> {
788 for pack in packs {
789 for &kind in pack.brain_consumer_kinds() {
790 if kind == "*" || kind.trim().is_empty() || kind.trim() != kind {
791 return Err(RuntimeError::InvalidInput(format!(
792 "pack {:?} declares invalid brain consumer kind {kind:?}; declarations must be non-empty exact wire values and must not use the registry-owned \"*\" wildcard",
793 pack.name()
794 )));
795 }
796 }
797 }
798 Ok(())
799}
800
801fn validate_unique_verb_names(packs: &[Box<dyn PackRuntime>]) -> Result<(), RuntimeError> {
808 let mut seen: HashMap<&str, &str> = HashMap::new();
809 for pack in packs {
810 for handler in pack.handlers() {
811 if !matches!(handler.visibility, Visibility::Verb) {
812 continue;
813 }
814 if let Some(first_pack) = seen.insert(handler.name, pack.name()) {
815 return Err(RuntimeError::VerbCollision {
816 verb: handler.name.to_string(),
817 first_pack: first_pack.to_string(),
818 second_pack: pack.name().to_string(),
819 });
820 }
821 }
822 }
823 Ok(())
824}
825
826fn validate_unique_entity_types(packs: &[Box<dyn PackRuntime>]) -> Result<(), RuntimeError> {
836 let owned_defs = packs
837 .iter()
838 .flat_map(|p| p.entity_types().iter().map(move |def| (p.name(), def)));
839 khive_types::EntityTypeRegistry::check_extra_collisions(owned_defs)
840 .map_err(RuntimeError::InvalidInput)
841}
842
843fn validate_entity_type_note_kind_collisions(
847 packs: &[Box<dyn PackRuntime>],
848) -> Result<(), RuntimeError> {
849 let mut note_kinds = HashMap::new();
850 for pack in packs {
851 for &kind in pack.note_kinds() {
852 note_kinds
853 .entry(khive_types::to_snake_case(kind))
854 .or_insert(pack.name());
855 }
856 }
857
858 let check_definition = |definition: &EntityTypeDef, owner: &str| {
859 for name in std::iter::once(definition.type_name).chain(definition.aliases.iter().copied())
860 {
861 let normalized = khive_types::to_snake_case(name);
862 if let Some(note_owner) = note_kinds.get(&normalized) {
863 return Err(RuntimeError::InvalidInput(format!(
864 "entity subtype {name:?} from {owner:?} collides with note kind {normalized:?} from pack {note_owner:?}"
865 )));
866 }
867 }
868 Ok(())
869 };
870
871 let builtin = khive_types::EntityTypeRegistry::builtin();
872 for definition in builtin.definitions() {
873 check_definition(definition, "builtin")?;
874 }
875 for pack in packs {
876 for definition in pack.entity_types() {
877 check_definition(definition, pack.name())?;
878 }
879 }
880 Ok(())
881}
882
883fn find_pack_dependency_cycle(
884 packs: &[Box<dyn PackRuntime>],
885 name_to_idx: &HashMap<&str, usize>,
886 cycle_nodes: &HashSet<usize>,
887) -> Vec<String> {
888 fn visit(
889 idx: usize,
890 packs: &[Box<dyn PackRuntime>],
891 name_to_idx: &HashMap<&str, usize>,
892 cycle_nodes: &HashSet<usize>,
893 visiting: &mut Vec<usize>,
894 visited: &mut HashSet<usize>,
895 ) -> Option<Vec<String>> {
896 if let Some(pos) = visiting.iter().position(|&seen| seen == idx) {
897 let mut cycle: Vec<String> = visiting[pos..]
898 .iter()
899 .map(|&i| packs[i].name().to_string())
900 .collect();
901 cycle.push(packs[idx].name().to_string());
902 return Some(cycle);
903 }
904 if !visited.insert(idx) {
905 return None;
906 }
907 visiting.push(idx);
908 for &req in packs[idx].requires() {
909 let Some(&dep_idx) = name_to_idx.get(req) else {
910 continue;
911 };
912 if cycle_nodes.contains(&dep_idx) {
913 if let Some(cycle) =
914 visit(dep_idx, packs, name_to_idx, cycle_nodes, visiting, visited)
915 {
916 return Some(cycle);
917 }
918 }
919 }
920 visiting.pop();
921 None
922 }
923
924 let mut visited = HashSet::new();
925 for &idx in cycle_nodes {
926 let mut visiting = Vec::new();
927 if let Some(cycle) = visit(
928 idx,
929 packs,
930 name_to_idx,
931 cycle_nodes,
932 &mut visiting,
933 &mut visited,
934 ) {
935 return cycle;
936 }
937 }
938 cycle_nodes
939 .iter()
940 .map(|&idx| packs[idx].name().to_string())
941 .collect()
942}
943
944impl Default for VerbRegistryBuilder {
945 fn default() -> Self {
946 Self::new()
947 }
948}
949
950pub struct PackMetadataRegistry {
958 pub(super) registry: VerbRegistry,
959}
960
961impl PackMetadataRegistry {
962 pub fn has_verb(&self, verb: &str) -> bool {
963 self.registry.has_verb(verb)
964 }
965
966 pub fn describe_verb(&self, verb: &str) -> Result<Value, RuntimeError> {
967 self.registry.describe_verb(verb)
968 }
969
970 pub fn all_handlers_with_names(&self) -> Vec<(&str, &'static HandlerDef)> {
971 self.registry.all_handlers_with_names()
972 }
973
974 pub fn all_verbs(&self) -> Vec<&'static HandlerDef> {
975 self.registry.all_verbs()
976 }
977
978 pub fn pack_names(&self) -> Vec<&str> {
979 self.registry.pack_names()
980 }
981
982 pub fn pack_version(&self, name: &str) -> Option<&'static str> {
984 self.registry.pack_version(name)
985 }
986
987 pub fn pack_requires(&self, name: &str) -> Option<&'static [&'static str]> {
988 self.registry.pack_requires(name)
989 }
990
991 pub fn pack_note_kinds(&self, name: &str) -> Option<&'static [&'static str]> {
992 self.registry.pack_note_kinds(name)
993 }
994
995 pub fn pack_entity_kinds(&self, name: &str) -> Option<&'static [&'static str]> {
996 self.registry.pack_entity_kinds(name)
997 }
998
999 pub fn pack_verbs(&self, name: &str) -> Option<&'static [HandlerDef]> {
1000 self.registry.pack_verbs(name)
1001 }
1002
1003 pub fn all_entity_kinds(&self) -> Vec<&'static str> {
1004 self.registry.all_entity_kinds()
1005 }
1006
1007 pub fn all_note_kinds(&self) -> Vec<&'static str> {
1008 self.registry.all_note_kinds()
1009 }
1010
1011 pub fn all_edge_rules(&self) -> Vec<EdgeEndpointRule> {
1012 self.registry.all_edge_rules()
1013 }
1014
1015 pub fn all_edge_rules_with_packs(&self) -> Vec<(&str, EdgeEndpointRule)> {
1017 self.registry.all_edge_rules_with_packs()
1018 }
1019}