Ship oracle journal values, bytecode/frontend hardening, and replay-policy Lean.

Host exposes oracle journals as language values with refuse/copy gates; bytecode and foreign session paths get modularized; applications and verification replay-policy sources land with Lake builds ignored.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
cflmyandCursor committed 2026-11-06 15:04:27 +08:00
1 parent e3d9021bb6
commit 8f1010f967
101 files changed
+17962 -1727

No files matched your search

+439
View File
@@ -0,0 +1,439 @@
//! Source-directed expression emission obligations. Call staging and selection
//! are checked separately in call.rs; dispatch semantics remain a proof boundary.
use super::{FnChunk, Op};
use crate::{
ast::{BinaryOp, Expr, IndexKey, InterpPart, Literal, UnaryOp},
value::Value,
};
#[derive(Debug, Clone)]
pub enum ExpressionRule {
Literal(Value),
Read(String),
Unary(UnaryOp),
Binary(BinaryOp),
Interpolation(Vec<InterpPart>),
List(usize),
Map(Vec<String>),
Index {
label: IndexKey,
base_variable: Option<String>,
},
Occluded(bool),
CallBoundary(Vec<String>),
CallFault(String),
}
impl ExpressionRule {
pub fn from_source(expr: &Expr) -> Self {
match expr {
Expr::Literal(value) => Self::Literal(match value {
Literal::None => Value::None,
Literal::Bool(v) => Value::Bool(*v),
Literal::Int(v) => Value::Int(*v),
Literal::Num(v) => Value::Num(*v),
Literal::Text(v) => Value::Text(v.clone()),
}),
Expr::Var(name) => Self::Read(name.clone()),
Expr::Unary { op, .. } => Self::Unary(*op),
Expr::Binary { op, .. } => Self::Binary(*op),
Expr::Interp(parts) => Self::Interpolation(parts.clone()),
Expr::List(items) => Self::List(items.len()),
Expr::Map(items) => Self::Map(items.iter().map(|(k, _)| k.clone()).collect()),
Expr::Index { base, label } => Self::Index {
label: label.clone(),
base_variable: if let Expr::Var(name) = base.as_ref() {
Some(name.clone())
} else {
None
},
},
Expr::Formula(value) => Self::Literal(Value::Formula(value.clone())),
Expr::Code(value) => Self::Literal(Value::Code(value.clone())),
Expr::Occluded { payload, .. } => Self::Occluded(payload.is_some()),
Expr::Call(call) if call.for_evaluation().is_err() => {
Self::CallFault(call.for_evaluation().unwrap_err())
}
Expr::Call(call) => Self::CallBoundary(
call.receiver
.iter()
.cloned()
.chain(call.path.iter().filter_map(|path| path.first().cloned()))
.collect(),
),
}
}
}
#[derive(Debug, Clone)]
pub struct ExpressionEmission {
pub rule: ExpressionRule,
pub start: usize,
pub end: usize,
pub children: Vec<usize>,
}
pub(super) fn formula_equal(a: &crate::formula::Expr, b: &crate::formula::Expr) -> bool {
use crate::formula::Expr::*;
match (a, b) {
(Num(x), Num(y)) => x.to_bits() == y.to_bits(),
(Var(x), Var(y)) => x == y,
(UnaryNeg(x), UnaryNeg(y)) => formula_equal(x, y),
(
Bin {
op: a,
left: x,
right: y,
},
Bin {
op: b,
left: u,
right: v,
},
) => a == b && formula_equal(x, u) && formula_equal(y, v),
(Call { name: a, args: x }, Call { name: b, args: y }) => {
a == b && x.len() == y.len() && x.iter().zip(y).all(|(a, b)| formula_equal(a, b))
}
(Matrix { source: a, rows: x }, Matrix { source: b, rows: y }) => {
a == b
&& x.len() == y.len()
&& x.iter().zip(y).all(|(a, b)| {
a.len() == b.len() && a.iter().zip(b).all(|(x, y)| x.to_bits() == y.to_bits())
})
}
_ => false,
}
}
fn value_equal(a: &Value, b: &Value) -> bool {
match (a, b) {
(Value::Num(x), Value::Num(y)) => x.to_bits() == y.to_bits(),
(Value::Formula(x), Value::Formula(y)) => formula_equal(x, y),
_ => a == b,
}
}
pub(super) struct Cursor<'a> {
pub(super) fun: &'a FnChunk,
pub(super) position: usize,
pub(super) end: usize,
}
impl Cursor<'_> {
pub(super) fn op(&mut self, expected: Op) -> Result<(), String> {
if self.position >= self.end || self.fun.code.get(self.position) != Some(&expected) {
return Err(format!(
"source expression opcode differs at {}: expected {expected:?}",
self.position
));
}
self.position += 1;
Ok(())
}
pub(super) fn literal(&mut self, value: &Value) -> Result<(), String> {
match value {
Value::None => self.op(Op::None_),
Value::Bool(true) => self.op(Op::True),
Value::Bool(false) => self.op(Op::False),
_ => {
let Some(Op::Constant(index)) = self.fun.code.get(self.position) else {
return Err("source literal is not a constant instruction".into());
};
if !self
.fun
.constants
.get(*index)
.is_some_and(|actual| value_equal(actual, value))
{
return Err("source literal value differs".into());
}
self.op(Op::Constant(*index))
}
}
}
fn read(&mut self, name: &str) -> Result<(), String> {
let slot = self
.fun
.locals
.iter()
.position(|local| local == name)
.ok_or("source variable has no slot")?;
self.op(Op::GetLocal(slot))
}
pub(super) fn child(&mut self, id: usize) -> Result<(), String> {
let child = &self.fun.expressions[id];
if child.start != self.position {
return Err("source operand order/range differs".into());
}
self.position = child.end;
Ok(())
}
}
pub fn verify(fun: &FnChunk) -> Result<usize, String> {
let mut boundaries = 0;
for (id, node) in fun.expressions.iter().enumerate() {
if node.start >= node.end || node.end > fun.code.len() {
return Err("invalid source expression interval".into());
}
for child in &node.children {
if *child <= id || *child >= fun.expressions.len() {
return Err("invalid source expression child".into());
}
let c = &fun.expressions[*child];
if c.start < node.start || c.end > node.end {
return Err("expression child outside parent".into());
}
}
let mut c = Cursor {
fun,
position: node.start,
end: node.end,
};
let expected_children = match &node.rule {
ExpressionRule::Literal(v) => {
c.literal(v)?;
0
}
ExpressionRule::Read(name) => {
c.read(name)?;
0
}
ExpressionRule::Unary(op) => {
if node.children.len() != 1 {
return Err("unary source arity".into());
}
c.child(node.children[0])?;
c.op(match op {
UnaryOp::Not => Op::Not,
UnaryOp::Neg => Op::Negate,
})?;
1
}
ExpressionRule::Binary(op) => {
if node.children.len() != 2 {
return Err("binary source arity".into());
}
let left = &fun.expressions[node.children[0]];
let right = &fun.expressions[node.children[1]];
c.child(node.children[0])?;
match op {
BinaryOp::And => {
c.op(Op::JumpIfFalse(right.end + 5))?;
c.child(node.children[1])?;
for op in [
Op::JumpIfFalse(right.end + 3),
Op::True,
Op::Jump(node.end),
Op::False,
Op::Jump(node.end),
Op::False,
] {
c.op(op)?;
}
}
BinaryOp::Or => {
c.op(Op::JumpIfFalse(right.start))?;
c.op(Op::True)?;
c.op(Op::Jump(node.end))?;
c.child(node.children[1])?;
for op in [
Op::JumpIfFalse(right.end + 3),
Op::True,
Op::Jump(node.end),
Op::False,
] {
c.op(op)?;
}
}
_ => {
let _ = left;
c.child(node.children[1])?;
c.op(match op {
BinaryOp::Add => Op::Add,
BinaryOp::Sub => Op::Sub,
BinaryOp::Mul => Op::Mul,
BinaryOp::Div => Op::Div,
BinaryOp::Eq => Op::Equal,
BinaryOp::Ne => Op::NotEqual,
BinaryOp::Lt => Op::Less,
BinaryOp::Le => Op::Lessequal,
BinaryOp::Gt => Op::Greater,
BinaryOp::Ge => Op::GreaterEqual,
_ => unreachable!(),
})?;
}
}
2
}
ExpressionRule::List(count) => {
for child in &node.children {
c.child(*child)?;
}
c.op(Op::BuildList(*count))?;
*count
}
ExpressionRule::Map(keys) => {
if node.children.len() != keys.len() {
return Err("map source arity".into());
}
for (key, child) in keys.iter().zip(&node.children) {
c.literal(&Value::Text(key.clone()))?;
c.child(*child)?;
}
c.op(Op::BuildMap(keys.len()))?;
keys.len()
}
ExpressionRule::Occluded(payload) => {
if *payload {
if node.children.len() != 1 {
return Err("occluded source arity".into());
}
c.child(node.children[0])?;
1
} else {
c.literal(&Value::None)?;
0
}
}
ExpressionRule::Index {
label,
base_variable,
} => {
if node.children.len() != 1 {
return Err("index source arity".into());
}
c.child(node.children[0])?;
match label {
IndexKey::Lit(key) => c.literal(&Value::Text(key.clone()))?,
IndexKey::Var(name) => {
c.read(name)?;
c.op(Op::Str)?;
}
}
if let Some(name) = base_variable
.as_ref()
.filter(|name| fun.var_contracts.contains_key(*name))
{
let slot = fun
.locals
.iter()
.position(|local| local == name)
.ok_or("index source slot")?;
c.op(Op::ContractFootnoteGet(slot))?;
} else {
c.op(Op::FootnoteGet)?;
}
1
}
ExpressionRule::Interpolation(parts) => {
if parts.is_empty() {
c.literal(&Value::Text(String::new()))?;
}
for (i, part) in parts.iter().enumerate() {
match part {
InterpPart::Lit(value) => c.literal(&Value::Text(value.clone()))?,
InterpPart::Var(name) => c.read(name)?,
InterpPart::Index { base, labels } => {
c.read(base)?;
for label in labels {
c.literal(&Value::Text(label.clone()))?;
c.op(Op::FootnoteGet)?;
}
}
}
c.op(Op::Str)?;
if i > 0 {
c.op(Op::Add)?;
}
}
0
}
ExpressionRule::CallFault(message) => {
let Some(Op::RejectArgumentExpansion(index)) = fun.code.get(c.position) else {
return Err("missing argument preparation fault".into());
};
if fun.constants.get(*index) != Some(&Value::Text(message.clone())) {
return Err("argument preparation message differs".into());
}
c.op(Op::RejectArgumentExpansion(*index))?;
0
}
ExpressionRule::CallBoundary(_) => {
boundaries += 1;
continue;
}
};
if node.children.len() != expected_children || c.position != node.end {
return Err("source expression coverage differs".into());
}
}
Ok(boundaries)
}
/// Local evidence preserves machine values, not the narrower foreign copy domain.
pub(super) fn interpolation_evidence(part: &InterpPart) -> serde_json::Value {
use serde_json::json;
match part {
InterpPart::Lit(value) => json!({"kind":"text","value":value}),
InterpPart::Var(name) => json!({"kind":"read","name":name}),
InterpPart::Index { base, labels } => json!({"kind":"index","base":base,"labels":labels}),
}
}
pub(super) fn index_evidence(key: &IndexKey) -> serde_json::Value {
use serde_json::json;
match key {
IndexKey::Lit(value) => json!({"kind":"literal","value":value}),
IndexKey::Var(name) => json!({"kind":"read","name":name}),
}
}
pub(super) fn formula_evidence(value: &crate::formula::Expr) -> serde_json::Value {
use crate::formula::Expr::*;
use serde_json::json;
match value {
Num(n) => json!({"kind":"number","bits":n.to_bits()}),
Var(name) => json!({"kind":"variable","name":name}),
UnaryNeg(value) => json!({"kind":"negative","value":formula_evidence(value)}),
Bin { op, left, right } => {
json!({"kind":"binary","op":format!("{op:?}"),"left":formula_evidence(left),"right":formula_evidence(right)})
}
Call { name, args } => {
json!({"kind":"call","name":name,"args":args.iter().map(formula_evidence).collect::<Vec<_>>()})
}
Matrix { source, rows } => {
json!({"kind":"matrix","source":source,"rows":rows.iter().map(|row|row.iter().map(|n|n.to_bits()).collect::<Vec<_>>()).collect::<Vec<_>>()})
}
}
}
pub fn value_evidence(value: &Value) -> serde_json::Value {
use serde_json::json;
match value {
Value::None => json!({"tag":"none"}),
Value::Bool(v) => json!({"tag":"bool","value":v}),
Value::Int(v) => json!({"tag":"int","value":v}),
Value::Num(v) => json!({"tag":"num","bits":v.to_bits()}),
Value::Text(v) => json!({"tag":"text","value":v}),
Value::Code(v) => json!({"tag":"code","lang":v.lang,"source":v.source}),
Value::Formula(v) => json!({"tag":"formula","value":formula_evidence(v)}),
_ => json!({"tag":"nonliteral","value":format!("{value:?}")}),
}
}
impl ExpressionRule {
pub fn evidence(&self) -> serde_json::Value {
use serde_json::json;
match self {
Self::Literal(v) => json!({"kind":"literal","value":value_evidence(v)}),
Self::Read(name) => json!({"kind":"read","name":name}),
Self::Unary(op) => json!({"kind":"unary","op":format!("{op:?}")}),
Self::Binary(op) => json!({"kind":"binary","op":format!("{op:?}")}),
Self::CallBoundary(names) => json!({"kind":"call_boundary","names":names}),
Self::CallFault(message) => json!({"kind":"call_expansion_fault","message":message}),
Self::Interpolation(parts) => {
json!({"kind":"interpolation_boundary","parts":parts.iter().map(interpolation_evidence).collect::<Vec<_>>()})
}
Self::List(n) => json!({"kind":"list","arity":n}),
Self::Map(keys) => json!({"kind":"map","keys":keys}),
Self::Index {
label,
base_variable,
} => {
json!({"kind":"index_boundary","label":index_evidence(label),"base_variable":base_variable})
}
Self::Occluded(payload) => json!({"kind":"occluded","payload":payload}),
}
}
}