Skip to main content

vbl_runtime/
form.rs

1//! Forma ativa no runtime (FORMAL §4.1).
2//!
3//! Abstracionismo de tipos: nenhuma variável inerte — toda estrutura tem
4//! `horizon` explícito (ABSOLUTO, contado da criação; reclassificações não o
5//! renovam — Lei 1). O `value` é conteúdo lógico opaco ao motor.
6//!
7//! Orçamentos de retenção (ADR-001): os contadores do runtime são PROXY
8//! determinístico de heap (livro-razão por forma); a medição física
9//! (`size_of` + arenas, miri/ASan) fecha na Etapa 5 (PLAN §5.1).
10
11use crate::fxp::Value;
12use vbl_lang::Conjugation;
13
14/// Valor poético canônico da subversão (FORMAL §4.5).
15pub const CANONICAL_POETIC_VALUE: &str =
16    "poesia_gerada_pelo_calor_do_silicio_e_resfriamento_da_mente";
17
18/// Orçamentos de retenção por conjugação em bytes (ADR-001).
19pub const RETENTION_BUDGET: (u64, u64, u64) = (256, 1024, 512); // event, equilibrium, nonequilibrium
20
21/// Ações compiladas para o runtime (threshold já convertido para número puro).
22#[derive(Debug, Clone, PartialEq)]
23pub enum ActionRt {
24    Dissolve,
25    Subvert,
26    ReclassifyEquilibrium,
27    ReclassifyNonequilibrium,
28    NotifyShutdown,
29    Act { actor: String, value: Value },
30}
31
32/// Regra de revisão compilada.
33#[derive(Debug, Clone, PartialEq)]
34pub struct RuleRt {
35    pub sensor: String,
36    pub op: vbl_lang::CmpOp,
37    pub threshold: f64,
38    pub actions: Vec<ActionRt>,
39}
40
41/// Conjugação com estado de manutenção (`nonequilibrium` apenas).
42#[derive(Debug, Clone, PartialEq)]
43pub struct Maintenance {
44    /// Prazo entre manutenções (s) — o DECLARADO sobrevive a reclassificações.
45    pub deadline_s: f64,
46    /// Instante virtual da última manutenção (keep implícito ou explícito).
47    pub last: f64,
48}
49
50/// Forma ativa.
51#[derive(Debug, Clone)]
52pub struct Form {
53    pub name: String,
54    pub value: Value,
55    /// Horizon em segundos — ABSOLUTO desde `creation_time` (FORMAL §4.1).
56    pub horizon_s: f64,
57    /// Instante virtual de criação; preservado nas reclassificações.
58    pub creation_time: f64,
59    pub conjugation: Conjugation,
60    /// `currency` de contabilização no Caderno (padrão da conjugação).
61    pub currency: String,
62    /// Nome simbólico do sensor principal (FORMAL §3), se declarado.
63    pub source_path: Option<String>,
64    /// Anotação de auditoria (sem efeito semântico — FORMAL §3).
65    pub classification: Option<String>,
66    /// Prazo declarado alguma vez pela forma (habilita NEQ→EQ→NEQ — FORMAL §3).
67    pub declared_maintenance_deadline: Option<f64>,
68    /// Estado de manutenção; `Some` apenas em `nonequilibrium`.
69    pub maintenance: Option<Maintenance>,
70    /// Anotação de auditoria `cooperation`/`extraction` (PLAN §2.2).
71    pub exchange_mode: Option<String>,
72    /// Custo em bytes (`equilibrium`); `None` → tamanho real gravado (§4.1).
73    pub cost_bytes: Option<u64>,
74    /// Regras de revisão ativas (sobrevivem à reclassificação — Etapa 1).
75    pub rules: Vec<RuleRt>,
76    pub dissolved: bool,
77    /// Versão do estado do horizon (muda na (re)classificação) — o
78    /// escalonador descarta entradas obsoletas pela versão.
79    pub horizon_version: u64,
80    /// Versão do estado de manutenção (`keep` renova; 0 fora de NEQ).
81    pub maintenance_version: u64,
82}
83
84impl Form {
85    /// Cabe em que instante a forma expira (criação + horizon).
86    pub fn horizon_end(&self) -> f64 {
87        self.creation_time + self.horizon_s
88    }
89
90    /// `horizon` esgotado? (`>=` — no limite exato expira; Etapa 1, FORMAL §4.1)
91    pub fn horizon_exhausted(&self, now: f64) -> bool {
92        (now - self.creation_time) >= self.horizon_s
93    }
94
95    /// Prazo de manutenção vencido? (`>` estritamente maior — Etapa 1)
96    pub fn maintenance_due(&self, now: f64) -> bool {
97        match &self.maintenance {
98            Some(m) => (now - m.last) > m.deadline_s,
99            None => false,
100        }
101    }
102
103    /// Manutenção: renova o prazo (keep implícito ou explícito).
104    pub fn keep(&mut self, now: f64) {
105        if let Some(m) = &mut self.maintenance {
106            m.last = now;
107        }
108    }
109
110    /// Contador de retenção do runtime (proxy de heap — ADR-001).
111    pub fn bytes_retidos(&self) -> u64 {
112        let base: u64 = match self.conjugation {
113            Conjugation::Event => 96,
114            Conjugation::Equilibrium => 128,
115            Conjugation::Nonequilibrium => 160,
116        };
117        let value = match &self.value {
118            Value::Num(n) => n.to_string().len(),
119            Value::Str(s) | Value::Ident(s) => s.len(),
120        } as u64;
121        base + value + 32 * self.rules.len() as u64
122    }
123}
124
125/// Registro de livros do runtime (contadores de retenção por forma).
126#[derive(Debug, Clone, Default)]
127pub struct Retention {
128    pub per_form: std::collections::BTreeMap<String, u64>,
129    /// Estruturas de trabalho laborativo (NEQ): prazo + último keep.
130    pub labor: std::collections::BTreeMap<String, u64>,
131}