//! Source paint dispatch produces checked immutable commands. One read-only VM //! call sequences all overrides, sharing a single instruction/frame budget. use crate::{ document::{Frame, RenderCommand}, layout::{self, Size}, mount::Mount, object_list, ui_bridge::{MAX_DIMENSION, UiNode, attach_desktop_type}, }; use anyhow::{Result, bail}; use endor_core::{ CodeLayout, ContextNativeFunction, EndorCode, EndorCodeObject, Instruction, NativeCallable, NativeContext, NativeResult, ObjectRef, ObjectStore, Opcode, Value, Vm, VmError, WeakObjectRef, }; use std::{ collections::{BTreeMap, BTreeSet, HashMap}, sync::{Arc, Mutex}, }; fn invalid(message: &'static str) -> VmError { VmError::InvalidArgument(message) } fn object(value: Value) -> Result { if let Value::Object(object) = value { Ok(object) } else { Err(invalid("paint must return managed objects")) } } fn text(store: &ObjectStore, object: ObjectRef, name: &str) -> Result { if let Value::Text(value) = store.get_attr(object, name)? { Ok(value) } else { Err(invalid("paint field must be text")) } } fn number(store: &ObjectStore, object: ObjectRef, name: &str) -> Result { let Value::Number(value) = store.get_attr(object, name)? else { return Err(invalid("paint field must be a Number")); }; let value = value .to_string() .parse::() .map_err(|_| invalid("invalid paint number"))?; if !value.is_finite() || !(0.0..=MAX_DIMENSION as f32).contains(&value) { return Err(invalid("paint number exceeds bounds")); } Ok(value) } fn named_type(store: &ObjectStore, desktop: ObjectRef, name: &str) -> Result { let registry = object(store.get_attr(desktop, "types")?)?; object( store .dict_get(registry, &Value::Text(name.into()))? .ok_or(invalid("missing paint type"))?, ) } fn decode( store: &ObjectStore, command: ObjectRef, expected: ObjectRef, ) -> Result { if !store.is_instance(command, expected)? { return Err(invalid("paint commands must be PaintCommand instances")); } let x = number(store, command, "x")?; let y = number(store, command, "y")?; let color = text(store, command, "color")?; let kind = text(store, command, "kind")?; let result = match kind.as_str() { "roundedRect" | "strokeRoundedRect" => { let width = number(store, command, "width")?; let height = number(store, command, "height")?; let radius = number(store, command, "radius")?; if x + width > MAX_DIMENSION as f32 || y + height > MAX_DIMENSION as f32 { return Err(invalid("paint rectangle exceeds bounds")); } if kind == "roundedRect" { RenderCommand::RoundedRect { x, y, width, height, radius, color, } } else { RenderCommand::StrokeRoundedRect { x, y, width, height, radius, color, stroke_width: number(store, command, "strokeWidth")?, } } } "text" => { let size = number(store, command, "size")?; if size.fract() != 0.0 || !(1.0..=8.0).contains(&size) { return Err(invalid("paint text size must be an integer from 1 to 8")); } RenderCommand::Text { x, y, value: text(store, command, "text")?, size: size as u32, color, } } _ => return Err(invalid("unsupported paint command kind")), }; result .validate() .map_err(|_| invalid("invalid paint command geometry, text or color"))?; Ok(result) } #[derive(Debug, Default)] struct PaintOutput { commands: BTreeMap>, count: usize, } type Output = Arc>; #[derive(Debug)] struct Collect { desktop: ObjectRef, mount: u64, output: Output, } impl NativeCallable for Collect { fn invoke(&self, cx: &mut NativeContext<'_>, args: &[Value]) -> Result { let [Value::Object(result)] = args else { return Err(invalid("paint must return a DisplayList")); }; if !cx.store().is_instance( *result, named_type(cx.store(), self.desktop, "DisplayList")?, )? { return Err(invalid("paint must return a DisplayList")); } let commands = object(cx.store().get_attr(*result, "commands")?)?; let expected = named_type(cx.store(), self.desktop, "PaintCommand")?; let commands = object_list::items(cx.store(), commands)? .iter() .map(|command| decode(cx.store(), *command, expected)) .collect::, _>>()?; let mut output = self .output .lock() .map_err(|_| invalid("paint output poisoned"))?; if output.count + commands.len() > 10_000 { return Err(invalid("paint command budget exceeded")); } output.count += commands.len(); output.commands.insert(self.mount, commands); Ok(NativeResult::Return(Value::Nil)) } } #[derive(Debug)] struct Prepare { desktop: ObjectRef, mounts: Vec<(u64, WeakObjectRef)>, output: Output, } impl NativeCallable for Prepare { fn invoke(&self, cx: &mut NativeContext<'_>, _: &[Value]) -> Result { let block_type = named_type(cx.store(), self.desktop, "Block")?; let native = cx .store() .lookup_method(block_type, "paint")? .ok_or(invalid("missing native paint"))?; let mut constants = Vec::new(); let mut instructions = Vec::new(); for (id, weak) in &self.mounts { let mount = cx .upgrade(*weak)? .ok_or(invalid("paint Mount has expired"))?; let data = cx.store().payload::(mount, "Mount")?.clone(); if !data.mounted { return Err(invalid("paint Mount is detached")); } let definition = cx .store() .type_of(data.block)? .ok_or(invalid("untyped paint target"))?; let function = cx .store() .lookup_method(definition, "paint")? .ok_or(invalid("missing paint method"))?; if function == native { continue; } let bounds = cx.new_object()?; attach_desktop_type(cx, bounds, "Bounds", self.desktop)?; for (name, value) in [ ("x", data.geometry.x), ("y", data.geometry.y), ("width", data.geometry.width), ("height", data.geometry.height), ] { cx.set_attr(bounds, name, Value::Number((value as f64).into()))?; } let collector = cx.allocate(ContextNativeFunction::new( "collect source paint", Collect { desktop: self.desktop, mount: *id, output: self.output.clone(), }, vec![self.desktop], ))?; let start = constants.len() as u32; constants.extend([ Value::Object(collector), Value::Object(function), Value::Object(data.block), Value::Object(mount), Value::Object(bounds), ]); instructions.extend([ Instruction::new(Opcode::LoadConst, start), Instruction::simple(Opcode::PushNull), Instruction::new(Opcode::LoadConst, start + 1), Instruction::simple(Opcode::PushNull), Instruction::new(Opcode::LoadConst, start + 2), Instruction::new(Opcode::LoadConst, start + 3), Instruction::new(Opcode::LoadConst, start + 4), Instruction::new(Opcode::Call, 3), Instruction::new(Opcode::Call, 1), Instruction::simple(Opcode::PopTop), ]); } if instructions.is_empty() { return Ok(NativeResult::Return(Value::Nil)); } let index = constants.len() as u32; constants.push(Value::Nil); instructions.extend([ Instruction::new(Opcode::LoadConst, index), Instruction::simple(Opcode::ReturnValue), ]); let code = EndorCode::from_instructions(&instructions, constants, CodeLayout::default())? .with_location("", "", 1); let code = cx.allocate(EndorCodeObject::new(code))?; let globals = cx.new_dict()?; let driver = cx.new_function("source paint", code, globals)?; Ok(NativeResult::Invoke { function: driver, arguments: vec![], }) } } pub fn render( vm: &mut Vm, desktop: ObjectRef, mounts: Vec<(u64, WeakObjectRef)>, root: Option<&UiNode>, frame: &mut Frame, ) -> Result> { let output = Arc::new(Mutex::new(PaintOutput::default())); let prepare = vm.allocate(ContextNativeFunction::new( "prepare source paint", Prepare { desktop, mounts, output: output.clone(), }, vec![desktop], ))?; let result = vm.call_read_only_with_limits( prepare, &[], endor_core::ExecutionLimits { max_frames: 128, max_instructions: 1_000_000, }, ); vm.release(prepare)?; let (value, reads) = result.map_err(|error| crate::endor_host::runtime_error(vm, error))?; vm.release_value(value)?; let output = output .lock() .map_err(|_| anyhow::anyhow!("paint output poisoned"))?; if output.commands.is_empty() { return Ok(BTreeSet::new()); } let mut nodes = HashMap::new(); let mut pending: Vec<_> = root.into_iter().collect(); while let Some(node) = pending.pop() { nodes.insert(node.block_id.as_str(), node); pending.extend(node.children().iter().map(|node| node.as_ref())); } let mut commands = Vec::new(); for mount in &frame.mounts { if let Some(custom) = output.commands.get(&mount.id) { commands.extend(custom.iter().cloned()); } else { let node = nodes .get(mount.block_id.as_str()) .ok_or_else(|| anyhow::anyhow!("paint projection has no node"))?; if let Some(command) = layout::paint_native( node, mount.x, mount.y, Size { width: mount.width, height: mount.height, }, ) { commands.push(command); } } if commands.len() > 10_000 { bail!("paint command budget exceeded"); } } frame.commands = commands; let registry = object(vm.get_attr(desktop, "types")?)?; Ok(reads .into_iter() .filter(|object| { *object != desktop && *object != registry && vm .object(*object) .is_ok_and(|object| !object.payload().as_any().is::()) }) .collect()) }