crates/laymesh-wasm/src/lib.rs 1//! Browser bindings compile retained scenes and sample animation for CanvasKit.2use laymesh_core::{3 engine::compile_preview_source,4 model::{Host, Scene},5};6use laymesh_language::{LanguageService, byte_offset, utf16_offset};7use serde_json::{Value as J, json};8use std::cell::RefCell;9use std::collections::{BTreeMap, BTreeSet};10use std::rc::Rc;11use std::sync::Arc;12use wasm_bindgen::prelude::*;13#[cfg(target_arch = "wasm32")]14#[wasm_bindgen]15pub fn rendering_memory_stats() -> Vec<f64> {16 laymesh_core::wasm_allocator::allocation_stats()17 .map(|v| v as f64)18 .to_vec()19}20#[wasm_bindgen]21extern "C" {22 #[wasm_bindgen(js_namespace=performance,js_name=now)]23 fn performance_now() -> f64;24}25thread_local! {26 static LANGUAGE_SERVICE: RefCell<LanguageService> = RefCell::new(LanguageService::new("en"));27 static PREVIEW_FONTS: RefCell<BTreeMap<String, Arc<Vec<u8>>>> = RefCell::new(BTreeMap::new());28 static PREVIEW_ASSETS: RefCell<BTreeMap<String, Arc<Vec<u8>>>> = RefCell::new(BTreeMap::new());29 static DRAW_RESOURCES: RefCell<BTreeMap<String, std::sync::Arc<Vec<u8>>>> = RefCell::new(BTreeMap::new());30 static PREVIEW_DEPENDENCIES: Rc<RefCell<BTreeSet<String>>> = Rc::new(RefCell::new(BTreeSet::new()));31}32 33#[wasm_bindgen]34pub fn clear_preview_dependencies() {35 PREVIEW_DEPENDENCIES.with(|paths| paths.borrow_mut().clear());36}37#[wasm_bindgen]38pub fn preview_dependencies() -> String {39 PREVIEW_DEPENDENCIES.with(|paths| serde_json::to_string(&*paths.borrow()).unwrap())40}41 42#[wasm_bindgen]43pub fn register_render_resource(id: &str, bytes: &[u8]) {44 DRAW_RESOURCES.with(|resources| {45 resources46 .borrow_mut()47 .insert(id.into(), std::sync::Arc::new(bytes.to_vec()))48 });49}50#[wasm_bindgen]51pub fn retain_render_resources(ids: &str) -> Result<(), JsValue> {52 let ids: Vec<String> = serde_json::from_str(ids).map_err(js_error)?;53 DRAW_RESOURCES.with(|r| r.borrow_mut().retain(|id, _| ids.contains(id)));54 Ok(())55}56fn js_error(e: impl std::fmt::Display) -> JsValue {57 JsValue::from_str(&e.to_string())58}59 60#[wasm_bindgen]61pub struct DrawJob {62 scene: laymesh_render::retained::RetainedScene,63 source: Option<(Arc<Scene>, bool)>,64}65#[wasm_bindgen]66impl DrawJob {67 pub fn presentation_state(&self, time: f64, reduced: bool) -> Result<String, JsValue> {68 serde_json::to_string(69 &self70 .scene71 .sample_presentation(time, reduced)72 .map_err(js_error)?,73 )74 .map_err(js_error)75 }76 pub fn frame_state(&self, time: f64, reduced: bool) -> Result<String, JsValue> {77 serde_json::to_string(&self.scene.sample(time, reduced, false).map_err(js_error)?)78 .map_err(js_error)79 }80 pub fn transform_state(&self, time: f64, reduced: bool) -> Result<String, JsValue> {81 serde_json::to_string(82 &self83 .scene84 .sample_transforms(time, reduced, false)85 .map_err(js_error)?,86 )87 .map_err(js_error)88 }89 pub fn resource_bytes(&self, id: &str) -> Result<Vec<u8>, JsValue> {90 self.scene91 .base()92 .resources93 .get(id)94 .map(|r| r.data.as_ref().clone())95 .ok_or_else(|| js_error("Missing drawing resource"))96 }97 /// Workers already own the drawing; the UI only needs its resource headers.98 /// Keep display_list() available for consumers that need complete commands.99 pub fn animation_sample(&self, time: f64, reduced: bool) -> Result<String, JsValue> {100 if !time.is_finite() || time < 0. {101 return Err(js_error("Invalid animation time"));102 }103 serde_json::to_string(104 &self105 .scene106 .base()107 .animation108 .as_ref()109 .map(|a| a.timeline(reduced).sample(time)),110 )111 .map_err(js_error)112 }113 pub fn drawing_info(&self) -> Result<String, JsValue> {114 let list = self.scene.base();115 let resources: BTreeMap<_, _> = list116 .resources117 .iter()118 .map(|(id, r)| {119 (120 id,121 json!({"mime":r.mime,"fontIndex":r.font_index,"family":r.family}),122 )123 })124 .collect();125 serde_json::to_string(&json!({"schemaVersion":list.schema_version,"width":list.width,"height":list.height,"resources":resources,"media":list.media,"animation":list.animation,"pageTransition":list.page_transition})).map_err(js_error)126 }127 /// Updates are accepted only after the client validates their baseline ID.128 pub fn update_display_list(&mut self, json: &str) -> Result<(), JsValue> {129 let mut update: laymesh_render::display_update::DisplayUpdate =130 serde_json::from_str(json).map_err(js_error)?;131 if let Some(resources) = &mut update.resources {132 resolve_resources(resources)?;133 }134 self.scene.update(update).map_err(js_error)?;135 self.source = None;136 Ok(())137 }138 pub fn display_list(&self) -> Result<String, JsValue> {139 let mut list = self.scene.base().clone();140 for resource in list.resources.values_mut() {141 resource.data = Default::default();142 }143 serde_json::to_string(&list).map_err(js_error)144 }145}146#[wasm_bindgen]147pub fn prepare_display_list(json: &str) -> Result<DrawJob, JsValue> {148 let mut list: laymesh_render::DisplayList = serde_json::from_str(json).map_err(js_error)?;149 if !laymesh_render::display_list::supported_version(list.schema_version) {150 return Err(js_error("Unsupported display list version"));151 }152 resolve_resources(&mut list.resources)?;153 Ok(DrawJob {154 scene: laymesh_render::retained::RetainedScene::new(list),155 source: None,156 })157}158fn resolve_resources(159 list: &mut BTreeMap<String, laymesh_render::display_list::Resource>,160) -> Result<(), JsValue> {161 DRAW_RESOURCES.with(|resources| {162 let resources = resources.borrow();163 for (id, resource) in list {164 if resource.data.is_empty() {165 resource.data = resources166 .get(id)167 .cloned()168 .ok_or_else(|| js_error(format!("Missing drawing resource {id}")))?;169 }170 }171 Ok::<(), JsValue>(())172 })173}174 175#[wasm_bindgen]176pub fn register_preview_asset(path: &str, bytes: &[u8]) {177 PREVIEW_ASSETS.with(|files| {178 let mut files = files.borrow_mut();179 if files.get(path).is_none_or(|old| old.as_slice() != bytes) {180 files.insert(path.into(), Arc::new(bytes.to_vec()));181 }182 });183}184#[wasm_bindgen]185pub fn clear_preview_assets() {186 PREVIEW_ASSETS.with(|files| files.borrow_mut().clear());187}188 189#[wasm_bindgen]190pub fn describe_font(bytes: &[u8]) -> String {191 serde_json::to_string(&laymesh_core::text::font_metadata(bytes)).unwrap()192}193#[wasm_bindgen]194pub fn decode_image(bytes: &[u8], path: &str) -> Result<String, JsValue> {195 laymesh_core::assets::load(bytes, path, path, laymesh_core::Loc::default())196 .and_then(|v| {197 serde_json::to_string(&v).map_err(|e| {198 laymesh_core::Diagnostic::new(199 "E_IMAGE",200 e.to_string(),201 path,202 laymesh_core::Loc::default(),203 )204 })205 })206 .map_err(js_error)207}208/// Register Page-only body fonts as bytes, avoiding a large JSON byte array on every render.209#[wasm_bindgen]210pub fn register_preview_font(filename: &str, bytes: &[u8]) {211 PREVIEW_FONTS.with(|fonts| {212 fonts213 .borrow_mut()214 .insert(filename.to_owned(), Arc::new(bytes.to_vec()));215 });216}217/// A scene remains in WASM memory between layout and SVG generation, avoiding218/// serialization of embedded fonts just to measure the two stages separately.219#[wasm_bindgen]220pub struct RenderJob {221 scene: Arc<Scene>,222 document: Option<J>,223}224/// A document plan is evaluated once per presentation snapshot. Page compilation225/// remains explicit so callers can report progress and cancel between pages.226#[wasm_bindgen]227pub struct PresentationPlan {228 plan: laymesh_core::document::DocumentPlan,229 host: Host,230}231#[wasm_bindgen]232impl PresentationPlan {233 pub fn metadata(&self) -> String {234 json!({"name":self.plan.name,"pages":self.plan.pages}).to_string()235 }236 pub fn page(&self, index: usize, files_json: &str) -> Result<RenderJob, JsValue> {237 let mut host = self.host.clone();238 let extra = render_host(files_json)?;239 host.files.extend(extra.files);240 host.shared_files.extend(extra.shared_files);241 let page = self.plan.page(index + 1).map_err(diagnostic_js_error)?;242 let scene = laymesh_core::document::compile_preview_page(page, host)243 .map_err(diagnostic_js_error)?;244 Ok(RenderJob {245 scene: Arc::new(scene),246 document: Some(247 json!({"name":self.plan.name,"pages":self.plan.pages,"pageId":page.id,"pageNumber":index+1}),248 ),249 })250 }251}252#[wasm_bindgen]253pub fn prepare_presentation(254 source: &str,255 filename: &str,256 files_json: &str,257) -> Result<PresentationPlan, JsValue> {258 let host = render_host(files_json)?;259 let plan = laymesh_core::document::plan_source(source, filename, host.clone())260 .map_err(diagnostic_js_error)?;261 Ok(PresentationPlan { plan, host })262}263#[wasm_bindgen]264impl RenderJob {265 pub fn draw_job_outlined(&self) -> Result<DrawJob, JsValue> {266 let mut list = laymesh_render::to_display_list(&self.scene).map_err(js_error)?;267 laymesh_render::display_list::outline_nodes(&mut list.nodes);268 Ok(DrawJob {269 scene: laymesh_render::retained::RetainedScene::new(list),270 source: Some((self.scene.clone(), true)),271 })272 }273 pub fn update_draw_job_incremental(274 &self,275 draw: &mut DrawJob,276 outlined: bool,277 ) -> Result<String, JsValue> {278 let mut update = if let Some((previous, _)) =279 draw.source.as_ref().filter(|(_, mode)| *mode == outlined)280 {281 laymesh_render::display_list::display_update_reusing(282 &self.scene,283 previous,284 draw.scene.base(),285 outlined,286 )287 .map_err(js_error)?288 } else {289 let mut next = laymesh_render::to_display_list(&self.scene).map_err(js_error)?;290 if outlined {291 laymesh_render::display_list::outline_nodes(&mut next.nodes);292 }293 laymesh_render::display_update::DisplayUpdate::between_incremental(294 draw.scene.base(),295 &next,296 )297 };298 let resources = update.resources.take();299 let mut value = serde_json::to_value(&update).map_err(js_error)?;300 if let Some(resources) = &resources {301 value["resources"] = resources302 .iter()303 .map(|(id, r)| {304 (305 id.clone(),306 json!({"mime":r.mime,"data":[],"fontIndex":r.font_index,"family":r.family}),307 )308 })309 .collect::<serde_json::Map<_, _>>()310 .into();311 }312 update.resources = resources;313 draw.scene.update(update).map_err(js_error)?;314 draw.source = Some((self.scene.clone(), outlined));315 Ok(value.to_string())316 }317 318 pub fn update_draw_job(&self, draw: &mut DrawJob) -> Result<(), JsValue> {319 let next = laymesh_render::to_display_list(&self.scene).map_err(js_error)?;320 let update =321 laymesh_render::display_update::DisplayUpdate::between(draw.scene.base(), &next);322 draw.scene.update(update).map_err(js_error)?;323 draw.source = Some((self.scene.clone(), false));324 Ok(())325 }326 pub fn draw_job(&self) -> Result<DrawJob, JsValue> {327 Ok(DrawJob {328 source: Some((self.scene.clone(), false)),329 scene: laymesh_render::retained::RetainedScene::new(330 laymesh_render::to_display_list(&self.scene).map_err(js_error)?,331 ),332 })333 }334 pub fn display_list(&self) -> Result<String, JsValue> {335 serde_json::to_string(&laymesh_render::to_display_list(&self.scene).map_err(js_error)?)336 .map_err(js_error)337 }338 pub fn svg(&self) -> Result<String, JsValue> {339 laymesh_render::render_svg(&self.scene).map_err(|e| JsValue::from_str(&e.to_string()))340 }341 pub fn inspection(&self) -> String {342 let mut value = json!({"inspection":laymesh_language::inspect::inspect_scene(&self.scene),"warnings":self.scene.warnings,"requestedFonts":self.scene.font_requests});343 if let Some(document) = &self.document {344 value["document"] = document.clone();345 }346 value.to_string()347 }348}349#[wasm_bindgen]350pub fn prepare_render(351 source: &str,352 filename: &str,353 files_json: &str,354) -> Result<RenderJob, JsValue> {355 let host = render_host(files_json)?;356 let scene = compile_preview_source(source, filename, host).map_err(diagnostic_js_error)?;357 Ok(RenderJob {358 scene: Arc::new(scene),359 document: None,360 })361}362#[wasm_bindgen]363pub fn prepare_document_render(364 source: &str,365 filename: &str,366 files_json: &str,367 page_id: &str,368) -> Result<RenderJob, JsValue> {369 let host = render_host(files_json)?;370 let plan = laymesh_core::document::plan_source(source, filename, host.clone())371 .map_err(diagnostic_js_error)?;372 let mut document = json!({"name":plan.name,"pages":plan.pages});373 let number = if page_id.is_empty() {374 1375 } else {376 plan.pages377 .iter()378 .position(|p| p.id == page_id)379 .ok_or_else(|| {380 JsValue::from_str(381 &json!({"code":"E_PAGE","file":filename,382 "message":"Selected page ID no longer exists","document":document})383 .to_string(),384 )385 })?386 + 1387 };388 let page = plan.page(number).map_err(diagnostic_js_error)?;389 document["pageId"] = json!(page.id);390 document["pageNumber"] = json!(number);391 let scene = laymesh_core::document::compile_preview_page(page, host).map_err(|e| {392 let mut error = diagnostic_value(e);393 error["document"] = document.clone();394 JsValue::from_str(&error.to_string())395 })?;396 Ok(RenderJob {397 scene: Arc::new(scene),398 document: Some(document),399 })400}401fn render_host(files_json: &str) -> Result<Host, JsValue> {402 let files: J =403 serde_json::from_str(files_json).map_err(|e| JsValue::from_str(&e.to_string()))?;404 let mut host = Host {405 native: false,406 dependencies: Some(PREVIEW_DEPENDENCIES.with(Rc::clone)),407 ..Host::default()408 };409 if let Some(files) = files.as_object() {410 for (name, value) in files {411 let data = if let Some(s) = value.as_str() {412 s.as_bytes().to_vec()413 } else if let Some(a) = value.as_array() {414 a.iter().map(|v| v.as_u64().unwrap_or(0) as u8).collect()415 } else {416 continue;417 };418 host.files.insert(name.clone(), data);419 }420 }421 PREVIEW_ASSETS.with(|files| {422 host.shared_files423 .extend(files.borrow().iter().map(|(k, v)| (k.clone(), v.clone())))424 });425 PREVIEW_FONTS.with(|fonts| {426 host.shared_files.extend(427 fonts428 .borrow()429 .iter()430 .map(|(name, data)| (name.clone(), data.clone())),431 );432 });433 Ok(host)434}435fn diagnostic_js_error(e: laymesh_core::Diagnostic) -> JsValue {436 JsValue::from_str(&diagnostic_value(e).to_string())437}438fn diagnostic_value(e: laymesh_core::Diagnostic) -> J {439 let mut diagnostic = serde_json::to_value(&e).unwrap();440 // Native errors remain unchanged. This extra field is a browser resource441 // request; the worker only honors paths in its local resource manifest.442 if e.code == "E_ASSET" {443 if let Some(path) = e.message.strip_prefix("无法读取资源:") {444 diagnostic["resource"] = json!(path);445 }446 }447 diagnostic448}449#[cfg(test)]450mod document_tests {451 use super::*;452 #[test]453 fn wasm_document_selection_matches_native_core_and_retained_commands() {454 let source = "d=document()\nfor p in [page(src=\"a.lay\",id=\"a\"),page(src=\"b.lay\",id=\"b\")] { d.add(p) }";455 let files=json!({"/a.lay":"p=canvas(size=(10,20))\np.add(rect(size=(4,4),fill=\"#f00\"))","/b.lay":"p=canvas(size=(2,1),unit=\"cm\")\np.add(rect(size=(0.4,0.4),fill=\"#00f\"))"}).to_string();456 let job = prepare_document_render(source, "/report.laydoc", &files, "b").unwrap();457 let info: J = serde_json::from_str(&job.inspection()).unwrap();458 assert_eq!(info["document"]["pageNumber"], 2);459 assert_eq!(info["inspection"]["page"]["unit"], "cm");460 let host = render_host(&files).unwrap();461 let plan =462 laymesh_core::document::plan_source(source, "/report.laydoc", host.clone()).unwrap();463 let scene = laymesh_core::document::compile_page(plan.page(2).unwrap(), host).unwrap();464 let list = laymesh_render::to_display_list(&scene).unwrap();465 let job = prepare_display_list(&serde_json::to_string(&list).unwrap()).unwrap();466 let commands: laymesh_render::DisplayList =467 serde_json::from_str(&job.display_list().unwrap()).unwrap();468 assert_eq!(commands.nodes, list.nodes);469 assert!(commands.resources.values().all(|r| r.data.is_empty()));470 for (id, r) in &list.resources {471 assert_eq!(472 job.resource_bytes(id).unwrap().as_slice(),473 r.data.as_slice()474 );475 }476 }477}478#[wasm_bindgen]479pub fn render(source: &str, filename: &str, files_json: &str) -> Result<String, JsValue> {480 let job = prepare_render(source, filename, files_json)?;481 let mut result: J = serde_json::from_str(&job.inspection()).unwrap();482 result["svg"] = json!(job.svg()?);483 Ok(result.to_string())484}485#[wasm_bindgen]486pub fn color_convert(input: &str) -> Result<String, JsValue> {487 let v: J = serde_json::from_str(input).map_err(|e| JsValue::from_str(&e.to_string()))?;488 let c = laymesh_core::color::Color::new(489 v["space"].as_str().unwrap_or("rgb"),490 [491 v["channels"][0].as_f64().unwrap_or(f64::NAN),492 v["channels"][1].as_f64().unwrap_or(f64::NAN),493 v["channels"][2].as_f64().unwrap_or(f64::NAN),494 ],495 v["alpha"].as_f64().unwrap_or(1.),496 )497 .map_err(|e| JsValue::from_str(&e))?;498 Ok(json!({"rgba":c.rgba,"mapped":c.mapped,"hex":c.hex(),"rgb":c.channels_in("rgb"),"hsv":c.channels_in("hsv"),"oklch":c.channels_in("oklch")}).to_string())499}500#[wasm_bindgen]501pub fn color_presentations(502 files: &str,503 filename: &str,504 from: usize,505 to: usize,506 rgba: &str,507) -> Result<String, JsValue> {508 let files: BTreeMap<String, String> =509 serde_json::from_str(files).map_err(|e| JsValue::from_str(&e.to_string()))?;510 let values: [f64; 4] =511 serde_json::from_str(rgba).map_err(|e| JsValue::from_str(&e.to_string()))?;512 let mut service = LanguageService::new("en");513 service.documents = files;514 let source = service515 .documents516 .get(filename)517 .map(String::as_str)518 .unwrap_or("");519 let mut result = service.color_presentations(520 filename,521 byte_offset(source, from),522 byte_offset(source, to),523 values,524 );525 for v in result.as_array_mut().unwrap() {526 v["from"] = json!(from);527 v["to"] = json!(to);528 }529 Ok(result.to_string())530}531#[wasm_bindgen]532pub fn language_query(533 files_json: &str,534 filename: &str,535 method: &str,536 utf16: usize,537 locale: &str,538) -> Result<String, JsValue> {539 let files: BTreeMap<String, String> =540 serde_json::from_str(files_json).map_err(|e| JsValue::from_str(&e.to_string()))?;541 LANGUAGE_SERVICE.with(|cached| {542 let mut service = cached.borrow_mut();543 service.locale = locale.into();544 service.documents = files;545 let source = service546 .documents547 .get(filename)548 .map(String::as_str)549 .unwrap_or("");550 let mut result = service.query(method, filename, byte_offset(source, utf16));551 fn convert(v: &mut J, source: &str, files: &BTreeMap<String, String>) {552 match v {553 J::Array(a) => {554 for x in a {555 convert(x, source, files)556 }557 }558 J::Object(m) => {559 let own = m560 .get("uri")561 .and_then(J::as_str)562 .and_then(|u| {563 files564 .get(u)565 .map(String::as_str)566 .or_else(|| laymesh_language::stylesheets::content(u))567 })568 .unwrap_or(source);569 for key in ["from", "to"] {570 if let Some(n) = m.get(key).and_then(J::as_u64) {571 m.insert(key.into(), json!(utf16_offset(own, n as usize)));572 }573 }574 for (key, value) in m.iter_mut() {575 if key != "from" && key != "to" {576 convert(value, own, files);577 }578 }579 }580 _ => {}581 }582 }583 convert(&mut result, source, &service.documents);584 Ok(result.to_string())585 })586}587 588/// Shared semantic compilation kernel, retained for the worker lifetime.589#[wasm_bindgen]590pub struct CompileSession {591 inner: laymesh_core::session::CompileSession,592 files: Host,593 plan: Option<laymesh_core::document::DocumentPlan>,594 entry: String,595}596#[wasm_bindgen]597impl CompileSession {598 #[wasm_bindgen(constructor)]599 pub fn new() -> Self {600 let mut inner = laymesh_core::session::CompileSession::new(false);601 inner.set_dependencies(Some(PREVIEW_DEPENDENCIES.with(Rc::clone)));602 Self {603 inner,604 files: Host::default(),605 plan: None,606 entry: String::new(),607 }608 }609 pub fn apply_changes(&mut self, revision: f64, changes: &str) -> Result<(), JsValue> {610 if !revision.is_finite()611 || revision.fract() != 0.612 || !(0. ..=9_007_199_254_740_991.).contains(&revision)613 {614 return Err(js_error("Invalid source version"));615 }616 let changes: BTreeMap<String, Option<String>> =617 serde_json::from_str(changes).map_err(js_error)?;618 let mut files = self.files.clone();619 for (path, value) in changes {620 match value {621 Some(value) => {622 files623 .shared_files624 .insert(path, Arc::new(value.into_bytes()));625 }626 None => {627 files.shared_files.remove(&path);628 }629 }630 }631 let resources = render_host("{}")?;632 let mut host = files.clone();633 host.shared_files.extend(resources.shared_files);634 host.dependencies = resources.dependencies;635 self.inner636 .sync_host(&host, revision as u64)637 .map_err(diagnostic_js_error)?;638 self.files = files;639 self.plan = None;640 Ok(())641 }642 pub fn set_time_slice(&mut self, milliseconds: f64) {643 self.inner.set_profile_clock(performance_now);644 self.inner645 .set_deadline((milliseconds > 0.).then(|| performance_now() + milliseconds));646 }647 pub fn set_budget(&mut self, bytes: usize) {648 self.inner.set_budget(bytes);649 }650 pub fn set_profiling(&mut self, enabled: bool) {651 self.inner.set_profile_clock(performance_now);652 self.inner.set_profiling(enabled);653 }654 pub fn metadata(&mut self, entry: &str) -> Result<String, JsValue> {655 self.entry = entry.into();656 self.plan = if entry.ends_with(".laydoc") {657 let source = self.inner.source(entry).map_err(diagnostic_js_error)?;658 Some(659 self.inner660 .plan(&source, entry)661 .map_err(diagnostic_js_error)?,662 )663 } else {664 None665 };666 Ok(if let Some(plan) = &self.plan {667 json!({"name":plan.name,"pages":plan.pages})668 } else {669 json!({"pages":[{"id":"page","name":entry.rsplit('/').next().unwrap_or(entry)}]})670 }671 .to_string())672 }673 pub fn set_active_page(&mut self, page_id: &str) {674 let file = self675 .plan676 .as_ref()677 .and_then(|p| p.pages.iter().find(|p| p.id == page_id))678 .map_or(self.entry.as_str(), |p| p.src.as_str());679 self.inner.set_focus_file(file);680 }681 pub fn evaluate(&mut self, page_id: &str) -> Result<RenderJob, JsValue> {682 let (file, transition, document) = if let Some(plan) = &self.plan {683 let index = plan684 .pages685 .iter()686 .position(|p| p.id == page_id)687 .ok_or_else(|| js_error("Selected page no longer exists"))?;688 let page = &plan.pages[index];689 (690 page.src.clone(),691 page.transition.clone(),692 Some(693 json!({"name":plan.name,"pages":plan.pages,"pageId":page.id,"pageNumber":index+1}),694 ),695 )696 } else {697 (self.entry.clone(), None, None)698 };699 let scene = if let Some(plan) = &self.plan {700 self.inner701 .evaluate_page(plan.pages.iter().find(|p| p.id == page_id).unwrap())702 } else {703 self.inner.evaluate_file(&file, transition)704 }705 .map_err(diagnostic_js_error)?;706 Ok(RenderJob { scene, document })707 }708 pub fn metrics(&self) -> String {709 serde_json::to_string(&self.inner.metrics()).unwrap()710 }711 pub fn snapshot(&self, file: &str) -> Option<RenderJob> {712 self.inner.snapshot(file).map(|(_, scene)| RenderJob {713 scene,714 document: None,715 })716 }717 pub fn dispose(&mut self) {718 self.inner.dispose();719 self.files.shared_files.clear();720 self.plan = None;721 }722}723#[wasm_bindgen]724pub fn remove_preview_asset(path: &str) {725 PREVIEW_ASSETS.with(|files| files.borrow_mut().remove(path));726}727 728/// Shared object-local 3D rasterizer; the host supplies its 2D subject texture.729#[wasm_bindgen]730pub fn raster_surface3d(731 mesh: &str,732 texture: &[u8],733 tw: u32,734 th: u32,735 region: &[f64],736 width: u32,737 height: u32,738) -> Result<Vec<u8>, JsValue> {739 let mesh: laymesh_render::surface3d::Mesh = serde_json::from_str(mesh).map_err(js_error)?;740 let region: [f64; 4] = region741 .try_into()742 .map_err(|_| js_error("Invalid surface region"))?;743 laymesh_render::surface3d::raster(&mesh, texture, tw, th, region, width, height)744 .map_err(js_error)745}746 747#[wasm_bindgen]748pub fn surface_texture_region(749 mesh: &str,750 region: &[f64],751 density: f64,752) -> Result<Vec<f64>, JsValue> {753 let mesh: laymesh_render::surface3d::Mesh = serde_json::from_str(mesh).map_err(js_error)?;754 let region: [f64; 4] = region755 .try_into()756 .map_err(|_| js_error("Invalid surface region"))?;757 Ok(758 laymesh_render::surface3d::texture_region(&mesh, region, density)759 .map_or_else(Vec::new, |r| r.to_vec()),760 )761}762 763/// Rebuild curved object geometry for the actual projected pixel density.764#[wasm_bindgen]765pub fn refine_surface3d(mesh: &str, density: f64) -> Result<String, JsValue> {766 let mesh: laymesh_render::surface3d::Mesh = serde_json::from_str(mesh).map_err(js_error)?;767 let mesh = laymesh_render::surface3d::refine(&mesh, density).map_err(js_error)?;768 serde_json::to_string(&mesh).map_err(js_error)769}770#[wasm_bindgen]771pub fn surface_material_texture(772 texture: &[u8],773 coverage: &[u8],774 width: u32,775 height: u32,776 material_alpha: Option<f64>,777) -> Result<Vec<u8>, JsValue> {778 laymesh_render::surface3d::material_texture(texture, coverage, width, height, material_alpha)779 .map_err(js_error)780}