pub(open) trait Clock {
  fn now_ms(self : Self) -> Int64
}

pub(open) trait ConflictJudge {
  fn judge(self : Self, new_fact : ExtractedFact, candidates : Array[MemoryEntry]) -> Result[Array[ConflictVerdict], MoomemError]
}

pub(open) trait Embedder {
  fn embed(self : Self, texts : Array[String]) -> Result[Array[Array[Double]], MoomemError]
  fn dim(self : Self) -> Int
}

pub(open) trait Extractor {
  fn extract(self : Self, user_id : String, text : String) -> Result[Array[ExtractedFact], MoomemError]
  fn mode(self : Self) -> String
}

pub(open) trait PersistenceBackend {
  fn load(self : Self) -> Result[String?, MoomemError]
  fn save(self : Self, snapshot : String) -> Result[Unit, MoomemError]
}

pub(all) suberror MoomemError {
  InvalidUserId(String)
  StoreCorrupted(String)
  IoFailure(String)
  ExtractionFailure(String)
  EmbeddingFailure(String)
  BackendUnsupported(String)
  InvalidOperation(String)
}

pub struct AddSummary {
  extracted : Int
  inserted : Int
  duplicates : Int
  superseded : Int
  degraded : Bool
  notes : Array[String]
}

pub(all) struct Config {
  embedder : &Embedder?
  extractor : &Extractor?
  judge : &ConflictJudge?
  persistence : &PersistenceBackend?
  clock : &Clock?
  dim : Int
  rrf_k : Int
  recall_candidates : Int
  supersede_threshold : Double
  conflict_candidates : Int
  coexist_band : Double
  backfill : RecallBackfill
  fusion_policy : FusionPolicy
  lexical_floor : Double
  lexical_gap : Double
  vector_weight_when_lexical : Double
  vector_weight_when_semantic : Double
}

pub(all) enum ConflictDecision {
  Replace
  Coexist
  Ignore
} derive(Eq)

pub(all) struct ConflictVerdict {
  existing : MemoryEntry
  decision : ConflictDecision
}

type DedupIndex

pub(all) enum EntryKind {
  Fact
  Preference
  Event
  Unstructured
} derive(Eq)

pub(all) enum EntryStatus {
  Active
  Superseded
  Deleted
  Unstructured
} derive(Eq)

pub(all) struct ExtractedFact {
  content : String
  kind : EntryKind
  source_span : String?
  degraded : Bool
  degrade_reason : String?
}

pub struct FixedClock {
  value : Int64
}

pub(all) enum ForgetTarget {
  ById(String)
  All
}

pub struct FsBackend {
  base_dir : String
  slot : Int
}

pub(all) enum FusionPolicy {
  EqualRrf
  AdaptiveLexical
}

pub struct HashingEmbedder {
  dim : Int
}

type KeywordIndex

pub struct LogicalClock {
  current : Int64
}

pub struct MemoryBackend {
  snapshot : String?
  simulate_partial_write : Int?
  fail_next_save : Bool
  bytes_written : Int64
}

pub(all) struct MemoryEntry {
  id : String
  user_id : String
  content : String
  kind : EntryKind
  embedding : Array[Double]
  keywords : Array[String]
  status : EntryStatus
  created_at : Int64
  superseded_by : String?
  seq : Int
  metadata : Map[String, Json]
}

pub struct MemoryStore {
  path : String
  embedder : &Embedder
  extractor : &Extractor
  judge : &ConflictJudge
  persistence : &PersistenceBackend
  clock : &Clock
  dim : Int
  rrf_k : Int
  recall_candidates : Int
  supersede_threshold : Double
  conflict_candidates : Int
  coexist_band : Double
  backfill : RecallBackfill
  fusion_policy : FusionPolicy
  lexical_floor : Double
  lexical_gap : Double
  vector_weight_when_lexical : Double
  vector_weight_when_semantic : Double
  entries : Map[String, MemoryEntry]
  by_user : Map[String, Array[String]]
  clock_high : Int64
  next_seq : Int
  gen : Int
  truncated_recovered : Int
  extraction_failures : Int
  last_write_at : Int64
  ever_flushed : Bool
  snapshot_bytes : Int64
  closed : Bool
  // private fields
}

pub struct RawExtractor {
}

pub(all) enum RecallBackfill {
  NoBackfill
  BackfillRecency
}

pub struct SimilarityJudge {
  threshold : Double
  embedder : &Embedder
  coexist_band : Double
}

pub struct StoreStats {
  total : Int
  active : Int
  superseded : Int
  deleted : Int
  unstructured : Int
  bytes_on_disk : Int64
  last_write_at : Int64?
  truncated_recovered : Int
  extractor_mode : String
}

type VectorIndex

let COEXIST_BAND : Double

let CONFLICT_CANDIDATES : Int

let DEFAULT_DIM : Int

let DEFAULT_LEXICAL_FLOOR : Double

let DEFAULT_LEXICAL_GAP : Double

let DEFAULT_RECALL_TOP_K : Int

let DEFAULT_RRF_K : Int

let DEFAULT_SUPERSEDE_THRESHOLD : Double

let DEFAULT_VECTOR_WEIGHT_LEXICAL : Double

let DEFAULT_VECTOR_WEIGHT_SEMANTIC : Double

let MAX_EXTRACTION_FAILURES : Int

let MAX_RECALL_TOP_K : Int

let MAX_USER_ID_LEN : Int

let MOOMEM_VERSION : String

let SNAPSHOT_VERSION : Int

fn default_backend(path : String) -> Result[&PersistenceBackend, MoomemError]

fn validate_user_id(user_id : String) -> Result[Unit, MoomemError]