diff --git a/Cargo.lock b/Cargo.lock index eddd4b0e..32773c27 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -11793,12 +11793,16 @@ dependencies = [ name = "octosense-pdf-service" version = "0.1.0" dependencies = [ + "chrono", + "libc", "makepad-widgets", "octosense-app-policy", "octosense-appstore", "octosense-engine-area", "octosense-skill-gen", + "pdfcraft-annot", "pdfcraft-automation", + "pdfcraft-cos", "pdfcraft-xfa", "serde_json", "tempfile", diff --git a/Cargo.toml b/Cargo.toml index bf6b9c94..9c7589ec 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -284,6 +284,10 @@ vectorcraft-format = { git = "https://github.com/ymote/vectorcraft.git", rev = " # The pdfcraft PDF engine (ADR 0013): the pinned ymote fork, one revision; # default features off to leave its MCP server out of the build. pdfcraft-automation = { git = "https://github.com/ymote/pdfcraft.git", rev = "d801407a9f956281d612dee3d2d72c76d43ef399", default-features = false } +# The pdf service's comment dates: the engine's own object reader and comment +# reader, which keep `/M` with its zone (the engine's listing drops it). +pdfcraft-cos = { git = "https://github.com/ymote/pdfcraft.git", rev = "d801407a9f956281d612dee3d2d72c76d43ef399" } +pdfcraft-annot = { git = "https://github.com/ymote/pdfcraft.git", rev = "d801407a9f956281d612dee3d2d72c76d43ef399" } # The pdf service's tests only: the engine's own scripted XFA form, the # hostile fixture of the scripts-off fence (ADR 0013). pdfcraft-xfa = { git = "https://github.com/ymote/pdfcraft.git", rev = "d801407a9f956281d612dee3d2d72c76d43ef399" } diff --git a/apps/AGENTS.md b/apps/AGENTS.md index fe022166..4d995e4a 100644 --- a/apps/AGENTS.md +++ b/apps/AGENTS.md @@ -110,9 +110,15 @@ app's own agent and `tools.json`, the system toolbox, `glance.publish` and proven by `doc_tests::a_forms_own_scripts_never_run`. Caps: 24–300 dpi and 16 MP a render, `find` ≤ 500 matches, 512 pages a call, an image export ≤ 64 pages and 256 MP in all (checked before anything is written), and a - render cache in `.cache/pages/` of 16 MiB and 64 files (an app's storage - holds at most 256 entries for its own writes), oldest first, cleared - before a write would fail with `storage_full:`. `pdf.fields` marks + render cache of 16 MiB and 64 files (an app's storage holds at most 256 + entries for its own writes): page renders in `.cache/pages/`, and, from + `pdf.cover` (a file method for apps, no agent tool), each PDF's first page + in `.cache/covers/`, at most 32 of them, kept across closes and runs and + named by the file's name, size and modification time (`src/covers.rs`). + Page renders go before covers, each oldest first, and the whole cache is + cleared before a write would fail with `storage_full:`. `pdf.comments` + reads each date with its zone from the file once per version of the + document (`src/review.rs`). `pdf.fields` marks read-only fields, and `pdf.fill` refuses one. Errors start with a stable code (`src/codes.rs`). - Declare an app's agent in its manifest and `bundle/tools.json`. Keep the diff --git a/apps/pdf/host-service/Cargo.toml b/apps/pdf/host-service/Cargo.toml index 18dd8d61..f8cbd297 100644 --- a/apps/pdf/host-service/Cargo.toml +++ b/apps/pdf/host-service/Cargo.toml @@ -25,6 +25,17 @@ serde_json = { workspace = true } # The engine, pinned to one ymote/pdfcraft revision (ADR 0013); default # features off to leave its MCP server out of the build. pdfcraft-automation = { workspace = true } +# A comment's date with its zone: the engine's object reader and comment +# reader, on the open document's working bytes, read only (src/review.rs). +pdfcraft-cos = { workspace = true } +pdfcraft-annot = { workspace = true } + +# This device's offset from UTC, from where the shell's status clock reads it +# (crates/shell/src/shell/bar.rs): localtime_r on Unix, chrono elsewhere. +[target.'cfg(unix)'.dependencies] +libc = "0.2" +[target.'cfg(not(unix))'.dependencies] +chrono = { workspace = true } [dev-dependencies] # Generates and checks the skill's references (tests/skill.rs). diff --git a/apps/pdf/host-service/src/cache.rs b/apps/pdf/host-service/src/cache.rs index b9bcf118..7e633f77 100644 --- a/apps/pdf/host-service/src/cache.rs +++ b/apps/pdf/host-service/src/cache.rs @@ -1,19 +1,27 @@ //! The render cache (SERVICE.md "Reading"): `pdf.page` writes each page it -//! renders to `.cache/pages//@.png` in the caller's storage. +//! renders to `.cache/pages//@.png` in the caller's storage, +//! and `pdf.cover` a PDF's first page to `.cache/covers/` ([`crate::covers`]). //! -//! - At most [`MAX_BYTES`] (16 MiB) and [`MAX_FILES`] renders per storage; -//! the oldest renders (by when they were written) go first. +//! - At most [`MAX_BYTES`] (16 MiB) and [`MAX_FILES`] renders per storage, +//! pages and covers together, at most [`MAX_COVERS`] of them covers. When +//! the cache needs room, page renders go before covers, each oldest first +//! (by when they were written). //! - The file cap is the service's own: an app's storage holds at most 256 //! entries for the app's own `fs` writes and `files.import` (makepad's //! `splash_storage::MAX_ENTRIES`), so a cache of hundreds of thumbnails //! would leave the app unable to save its library or import a PDF. +//! - A document's page renders go when it closes ([`forget`]) and when a +//! later open finds it gone ([`prune`]); both reach `.cache/pages` alone, +//! so covers stay across closes and runs. //! - Before any write of the service would fail for room -//! (`storage_full:`), the whole cache is cleared ([`make_room`]). +//! (`storage_full:`), the whole cache, covers too, is cleared +//! ([`make_room`]). //! - The cache is the service's: a render replaces a stale render of the //! same page and resolution, from any surface. It never walks or writes //! through a link: a cache folder that is a link is refused, and only //! regular files under plain folders are counted or removed. +use std::io::Read; use std::path::{Path, PathBuf}; use std::time::SystemTime; @@ -21,12 +29,16 @@ use octosense_engine_area::Area; use crate::codes::{self, fail, invalid, Code}; -/// The cache, relative to the storage. +/// The cache's page renders, relative to the storage. pub(crate) const DIR: &str = ".cache/pages"; +/// Its covers, relative to the storage. +pub(crate) const COVERS: &str = ".cache/covers"; /// The most bytes of renders one storage keeps. pub(crate) const MAX_BYTES: u64 = 16 << 20; /// The most renders one storage keeps. pub(crate) const MAX_FILES: usize = 64; +/// The most covers among them. +pub(crate) const MAX_COVERS: usize = 32; /// Where `pdf.page` writes page `page` of document `handle` at `dpi`. pub(crate) fn render_path(handle: &str, page: u64, dpi: u32) -> String { @@ -44,39 +56,66 @@ fn plain_dir(path: &Path, shown: &str) -> Result { } } -/// The cache's folder in `area`, when it is there and plain all the way. -fn root(area: &Area) -> Result, String> { +/// The cache's own folder in `area`, `.cache`, when it is there and plain. +fn cache_dir(area: &Area) -> Result, String> { let dot = area.root.join(".cache"); - if !plain_dir(&dot, ".cache")? { - return Ok(None); - } + Ok(plain_dir(&dot, ".cache")?.then_some(dot)) +} + +/// The page renders' folder in `area`, when it is there and plain all the +/// way. [`forget`] and [`prune`] reach nothing else. +fn root(area: &Area) -> Result, String> { + let Some(dot) = cache_dir(area)? else { return Ok(None) }; let pages = dot.join("pages"); Ok(plain_dir(&pages, DIR)?.then_some(pages)) } +/// The covers' folder in `area`, when it is there and plain all the way. +pub(crate) fn covers_root(area: &Area) -> Result, String> { + let Some(dot) = cache_dir(area)? else { return Ok(None) }; + let covers = dot.join("covers"); + Ok(plain_dir(&covers, COVERS)?.then_some(covers)) +} + struct Render { path: PathBuf, len: u64, written: SystemTime, + /// A cover (`.cache/covers`), not a page render. + cover: bool, } -/// Every render in the cache: regular files in the documents' plain -/// folders. Links and anything else are neither counted nor followed. -fn renders(root: &Path) -> Vec { - let mut out = Vec::new(); - let Ok(docs) = std::fs::read_dir(root) else { return out }; - for doc in docs.flatten() { - if !std::fs::symlink_metadata(doc.path()).is_ok_and(|m| m.is_dir()) { - continue; +/// The regular files directly in `dir`, as renders. +fn files_in(dir: &Path, cover: bool, out: &mut Vec) { + let Ok(files) = std::fs::read_dir(dir) else { return }; + for file in files.flatten() { + let Ok(meta) = std::fs::symlink_metadata(file.path()) else { continue }; + if meta.is_file() { + out.push(Render { path: file.path(), len: meta.len(), written: meta.modified().unwrap_or(SystemTime::UNIX_EPOCH), cover }); } - let Ok(files) = std::fs::read_dir(doc.path()) else { continue }; - for file in files.flatten() { - let Ok(meta) = std::fs::symlink_metadata(file.path()) else { continue }; - if meta.is_file() { - out.push(Render { path: file.path(), len: meta.len(), written: meta.modified().unwrap_or(SystemTime::UNIX_EPOCH) }); + } +} + +/// Every render in the cache folder `dot` (`.cache`): regular files in the +/// documents' plain folders under `pages/`, and in a plain `covers/`. +/// Links and anything else are neither counted nor followed. +fn renders(dot: &Path) -> Vec { + let mut out = Vec::new(); + let plain = |p: &Path| std::fs::symlink_metadata(p).is_ok_and(|m| m.is_dir()); + let pages = dot.join("pages"); + if plain(&pages) { + if let Ok(docs) = std::fs::read_dir(&pages) { + for doc in docs.flatten() { + if plain(&doc.path()) { + files_in(&doc.path(), false, &mut out); + } } } } + let covers = dot.join("covers"); + if plain(&covers) { + files_in(&covers, true, &mut out); + } out } @@ -92,47 +131,102 @@ fn drop_if_empty(dir: &Path) { pub(crate) struct Limits { pub bytes: u64, pub files: usize, + pub covers: usize, } -pub(crate) const LIMITS: Limits = Limits { bytes: MAX_BYTES, files: MAX_FILES }; +pub(crate) const LIMITS: Limits = Limits { bytes: MAX_BYTES, files: MAX_FILES, covers: MAX_COVERS }; -/// Make room in the cache at `root` for one more render of `incoming` -/// bytes at `keep` (which it replaces, so it does not count): the oldest -/// renders go first until the cache with it fits `limits`. -pub(crate) fn evict(root: &Path, keep: &Path, incoming: u64, limits: Limits) { - let mut all: Vec = renders(root).into_iter().filter(|r| r.path != keep).collect(); - all.sort_by_key(|r| r.written); - let mut bytes: u64 = all.iter().map(|r| r.len).sum(); - let mut files = all.len(); - for old in &all { +/// Make room in the cache folder `dot` (`.cache`) for one more render of +/// `incoming` bytes at `keep` (which it replaces, so it does not count): +/// covers past their cap go first, oldest first (a new cover at `keep` +/// counts); then page renders before covers, each oldest first, until the +/// cache with it fits `limits`. +pub(crate) fn evict(dot: &Path, keep: &Path, incoming: u64, limits: Limits) { + let keeps_cover = keep.parent() == Some(dot.join("covers").as_path()); + let mut all: Vec = renders(dot).into_iter().filter(|r| r.path != keep).collect(); + // Page renders before covers, each oldest first. + all.sort_by_key(|r| (r.cover, r.written)); + let cover_room = limits.covers.saturating_sub(usize::from(keeps_cover)); + let mut covers = all.iter().filter(|r| r.cover).count(); + let mut left: Vec = Vec::with_capacity(all.len()); + for old in all { + if old.cover && covers > cover_room && remove_render(&old, keep) { + covers -= 1; + } else { + left.push(old); + } + } + let mut bytes: u64 = left.iter().map(|r| r.len).sum(); + let mut files = left.len(); + for old in &left { if bytes.saturating_add(incoming) <= limits.bytes && files < limits.files { break; } - if std::fs::remove_file(&old.path).is_ok() { + if remove_render(old, keep) { bytes = bytes.saturating_sub(old.len); files -= 1; - if let Some(dir) = old.path.parent().filter(|d| Some(*d) != keep.parent()) { - drop_if_empty(dir); - } } } } -/// Clear the whole cache; the bytes it held. +/// Remove one render, and a page render's document folder once it is +/// empty (not the folder `keep` goes in). +fn remove_render(old: &Render, keep: &Path) -> bool { + if std::fs::remove_file(&old.path).is_err() { + return false; + } + if let Some(dir) = old.path.parent().filter(|d| !old.cover && Some(*d) != keep.parent()) { + drop_if_empty(dir); + } + true +} + +/// Clear the whole cache, page renders and covers; the bytes it held. fn clear(area: &Area) -> u64 { - let Ok(Some(root)) = root(area) else { return 0 }; + let Ok(Some(dot)) = cache_dir(area) else { return 0 }; let mut freed = 0; - for old in renders(&root) { + for old in renders(&dot) { if std::fs::remove_file(&old.path).is_ok() { freed += old.len; } - if let Some(dir) = old.path.parent() { + if let Some(dir) = old.path.parent().filter(|_| !old.cover) { drop_if_empty(dir); } } freed } +/// A cover kept at `rel` (in `.cache/covers`): its width and height from +/// its PNG header, if it is a regular file under plain folders whose header +/// reads as a PNG within the cache's bounds; `None` otherwise (draw it). +pub(crate) fn kept_png(area: &Area, rel: &str) -> Option<(u64, u64)> { + covers_root(area).ok()??; + let path = area.root.join(rel); + let meta = std::fs::symlink_metadata(&path).ok().filter(|m| m.is_file() && m.len() <= MAX_BYTES)?; + let mut head = [0u8; 24]; + std::fs::File::open(&path).ok()?.read_exact(&mut head).ok()?; + if meta.len() < 33 || &head[..8] != b"\x89PNG\r\n\x1a\n" || &head[12..16] != b"IHDR" { + return None; + } + let be = |at: usize| u64::from(u32::from_be_bytes([head[at], head[at + 1], head[at + 2], head[at + 3]])); + Some((be(16), be(20))).filter(|(w, h)| *w > 0 && *h > 0) +} + +/// Remove the covers in `.cache/covers` whose names start with `prefix` +/// (one PDF's covers, [`crate::covers`]) but not with `current` (its +/// current version's): a PDF's older covers, never another PDF's. +pub(crate) fn drop_covers(area: &Area, prefix: &str, current: &str) { + let Ok(Some(dir)) = covers_root(area) else { return }; + let Ok(files) = std::fs::read_dir(&dir) else { return }; + for file in files.flatten() { + let name = file.file_name(); + let Some(name) = name.to_str() else { continue }; + if name.starts_with(prefix) && !name.starts_with(current) && std::fs::symlink_metadata(file.path()).is_ok_and(|m| m.is_file()) { + let _ = std::fs::remove_file(file.path()); + } + } +} + /// Before a write of `need` bytes in `area`: when the storage has less /// room left, clear the render cache first and give the call the room it /// freed. The write's own check then answers `storage_full:` if that was @@ -165,11 +259,12 @@ pub(crate) fn store(area: &Area, rel: &str, png: &[u8]) -> Result<(), String> { // The folders on the way must be plain: a link would have the cache // count, trim or write files somewhere else in the storage. root(area)?; + covers_root(area)?; if let Some(dir) = target.parent() { plain_dir(dir, &area.shown(dir))?; } - if let Some(root) = root(area)? { - evict(&root, &target, len, LIMITS); + if let Some(dot) = cache_dir(area)? { + evict(&dot, &target, len, LIMITS); } make_room(area, len.saturating_sub(regular_len(&target))); // The service's own cache: a stale render of the same page goes, by an diff --git a/apps/pdf/host-service/src/change.rs b/apps/pdf/host-service/src/change.rs index d15b486f..9f339002 100644 --- a/apps/pdf/host-service/src/change.rs +++ b/apps/pdf/host-service/src/change.rs @@ -6,6 +6,17 @@ //! - `page_rotate`, `page_delete`, `page_move`, `page_duplicate`, //! `text_edit`, `edit_undo`, `edit_redo` and `doc_list` are `safe`: //! undoable edits of the open document, or reads of it. +//! - `text_edit`'s formatting: of the paragraph formatting the engine +//! offers, `pdf.edit_text` passes only `align` and `color`, formatting +//! alone (the paragraph is drawn again where it was, in its own font and +//! size): `align` as one of the engine's four names, `color` as a +//! `#rrggbb` the service writes itself from the three bytes it parsed +//! (never one of the engine's colour names), and both only with +//! `paragraph`, since the engine formats a paragraph, not a line. The +//! font (`font`, `bold`, `italic`), `size`, `underline`, the spacing +//! (`line_spacing`, `char_spacing`, `scale`) and the moves (`dx`, `dy`, +//! `width`) stay out: `pdf.edit_text` refuses each before the engine sees +//! the call. //! - `page_insert_file` is `file`: it reads the PDF at `path`. The path is //! the caller's, contained in its area and at most 128 MiB //! ([`crate::checked_input`]), and the engine's root-confined resolver @@ -48,6 +59,16 @@ pub(crate) const MAX_EXPORT_PAGES: usize = 64; pub(crate) const MAX_EXPORT_PIXELS: u64 = 256_000_000; /// The longest text an edit types. const MAX_EDIT: usize = 10_000; +/// A paragraph's alignments (SERVICE.md "Edit"), as the engine names them. +const ALIGNS: [&str; 4] = ["left", "center", "right", "justify"]; + +/// `#rrggbb` (either case) as the engine's `#rrggbb`, written from its +/// three bytes; `None` for anything else. +fn hex_color(color: &str) -> Option { + let hex = color.strip_prefix('#').filter(|h| h.len() == 6 && h.bytes().all(|b| b.is_ascii_hexdigit()))?; + let byte = |i: usize| u8::from_str_radix(&hex[i..i + 2], 16).ok(); + Some(format!("#{:02x}{:02x}{:02x}", byte(0)?, byte(2)?, byte(4)?)) +} /// Move what the engine wrote in `stage` into place under `area`'s rules, /// clearing the render cache first when the storage would be too full. @@ -157,17 +178,38 @@ pub(crate) fn pages(a: &Json, cx: &Ctx) -> Result { } } -/// `pdf.edit_text {doc, page, paragraph?, line?, text}`. +/// `pdf.edit_text {doc, page, paragraph?, line?, text, align?, color?}`: +/// `align` and `color` format a paragraph (the module doc's review). pub(crate) fn edit_text(a: &Json, cx: &Ctx) -> Result { const M: &str = "pdf.edit_text"; - args::only(a, &["doc", "page", "paragraph", "line", "text"], M)?; + args::only(a, &["doc", "page", "paragraph", "line", "text", "align", "color"], M)?; let page = args::positive(a, "page", M)?; let text = args::opt_str(a, "text", M, MAX_EDIT)?.ok_or_else(|| invalid(format!("{M} needs `text`")))?; let paragraph = args::opt_int(a, "paragraph", M)?; let line = args::opt_int(a, "line", M)?; + let align = match args::opt_str(a, "align", M, 16)? { + Some(al) if ALIGNS.contains(&al) => Some(al), + Some(al) => return Err(invalid(format!("{M}: `align` is {}, not {al:?}", ALIGNS.join(", ")))), + None => None, + }; + let color = match args::opt_str(a, "color", M, 16)? { + Some(c) => Some(hex_color(c).ok_or_else(|| invalid(format!("{M}: `color` is #rrggbb, not {c:?}")))?), + None => None, + }; let mut call = json!({ "page": page, "text": text }); match (paragraph, line) { - (Some(n), None) if n >= 1 => call["paragraph"] = json!(n), + (Some(n), None) if n >= 1 => { + call["paragraph"] = json!(n); + if let Some(align) = align { + call["align"] = json!(align); + } + if let Some(color) = color { + call["color"] = json!(color); + } + } + (None, Some(_)) if align.is_some() || color.is_some() => { + return Err(invalid(format!("{M}: `align` and `color` format a paragraph: give `paragraph`, a number from pdf.lines, not `line`"))); + } (None, Some(n)) if n >= 1 => call["line"] = json!(n), _ => return Err(invalid(format!("{M}: give exactly one of `paragraph` or `line`, a number from pdf.lines"))), } diff --git a/apps/pdf/host-service/src/covers.rs b/apps/pdf/host-service/src/covers.rs new file mode 100644 index 00000000..341e4de5 --- /dev/null +++ b/apps/pdf/host-service/src/covers.rs @@ -0,0 +1,96 @@ +//! Covers (SERVICE.md "Reading", `pdf.cover {path, dpi?}`): page 1 of a +//! PDF in the caller's storage, drawn once into the render cache's +//! `.cache/covers/` and kept there across closes and runs, so a library +//! shows its covers without opening each PDF on every start. +//! +//! - **The key.** A cover's file name is +//! `--@.png`: `` a hash of the PDF's +//! storage-relative name (16 lowercase hex digits), `` its bytes and +//! `` its modification time in nanoseconds since the epoch, all +//! digits. A PDF that changes (saved, or replaced under the same name) +//! gets another key, and writing its new cover removes the covers of its +//! other versions by the exact prefix `-`, which no other PDF's +//! covers carry ([`cache::drop_covers`]); a cover at another dpi of the +//! same version stays. +//! - **A kept cover** answers with no engine work: the file's metadata and +//! its PNG header ([`cache::kept_png`]). +//! - **A new cover** is drawn as `pdf.info {path}` reads a file: a fresh +//! session with JavaScript off ([`crate::session`]), `doc_open` (`code`, +//! run with scripts off) and `page_render` (`safe`), and no open +//! document: no handle, nothing in the open-document table, and nothing +//! counted toward a caller's 8. Its one write is the service's own cache +//! file, through [`cache::store`]'s bounds and link checks. +//! - **Caps.** 24 to 150 dpi (default 48), at most 16 megapixels; covers +//! share the render cache's 16 MiB and 64 files, at most 32 of them, and +//! page renders go before covers when the cache needs room ([`cache`]). +//! The whole cache, covers included, is cleared before a write would fail +//! with `storage_full:`. + +use std::path::{Component, Path}; +use std::time::UNIX_EPOCH; + +use pdfcraft_automation::Content; +use serde_json::{json, Value as Json}; + +use crate::args; +use crate::cache; +use crate::codes::{self, fail, Code}; +use crate::reading; +use crate::Ctx; + +/// `pdf.cover`'s resolutions (SERVICE.md: 24 to 150, default 48). +pub(crate) const DPI_RANGE: (u32, u32) = (24, 150); +pub(crate) const DEFAULT_DPI: u32 = 48; + +/// The key's first part for the storage-relative name `name`: FNV-1a over +/// its normal components joined with `/`, as 16 lowercase hex digits. +pub(crate) fn name_key(name: &str) -> String { + let joined: Vec = Path::new(name) + .components() + .filter_map(|c| match c { + Component::Normal(part) => Some(part.to_string_lossy().into_owned()), + _ => None, + }) + .collect(); + let mut hash: u64 = 0xcbf2_9ce4_8422_2325; + for byte in joined.join("/").bytes() { + hash ^= u64::from(byte); + hash = hash.wrapping_mul(0x0000_0100_0000_01b3); + } + format!("{hash:016x}") +} + +/// `pdf.cover {path, dpi?}`. +pub(crate) fn cover(a: &Json, cx: &Ctx) -> Result { + const M: &str = "pdf.cover"; + args::only(a, &["path", "dpi"], M)?; + let path = args::need_str(a, "path", M)?; + let dpi = args::dpi(a, "dpi", M, DEFAULT_DPI, DPI_RANGE)?; + crate::checked_input(cx.area, path, "path", M)?; + let file = crate::contained(cx.area, path, "path", M)?; + let meta = std::fs::metadata(&file).map_err(|e| codes::invalid(format!("{path}: {e}")))?; + let modified = meta.modified().ok().and_then(|t| t.duration_since(UNIX_EPOCH).ok()).map_or(0, |d| d.as_nanos()); + let prefix = format!("{}-", name_key(path)); + let current = format!("{prefix}{}-{modified}@", meta.len()); + let rel = format!("{}/{current}{dpi}.png", cache::COVERS); + if let Some((width, height)) = cache::kept_png(cx.area, &rel) { + return Ok(json!({ "path": rel, "width": width, "height": height, "dpi": dpi })); + } + let mut engine = crate::session(cx.area)?; + let (doc, pages) = crate::open(&mut engine, path)?; + if pages == 0 { + return Err(fail(Code::Damaged, format!("{path} has no pages"))); + } + let info = crate::run(&mut engine, "doc_info", &json!({ "doc": doc })).map_err(|e| codes::unreadable(&e))?; + let first = crate::docs::sizes_of(&info).first().copied().ok_or_else(|| fail(Code::Damaged, format!("{path} has no pages")))?; + reading::check_pixels(first, dpi, 1)?; + let contents = engine.call("page_render", &json!({ "doc": doc, "page": 1, "dpi": dpi })).map_err(|e| codes::refused(&e))?; + let Some(Content::Png { data, width, height }) = contents.into_iter().find(|c| matches!(c, Content::Png { .. })) else { + return Err(fail(Code::Damaged, format!("{path}'s first page could not be rendered"))); + }; + // This PDF's covers of other versions are stale: they go before the + // new one takes room. + cache::drop_covers(cx.area, &prefix, ¤t); + cache::store(cx.area, &rel, &data)?; + Ok(json!({ "path": rel, "width": width, "height": height, "dpi": dpi })) +} diff --git a/apps/pdf/host-service/src/dates.rs b/apps/pdf/host-service/src/dates.rs new file mode 100644 index 00000000..d6f9b421 --- /dev/null +++ b/apps/pdf/host-service/src/dates.rs @@ -0,0 +1,263 @@ +//! Dates as this device's local time (SERVICE.md "Comments": a comment's +//! `date` is local time without a zone or seconds, `YYYY-MM-DDTHH:MM`). +//! +//! A PDF writes a date with its zone (ISO 32000-2 §7.9.4, +//! `D:YYYYMMDDHHmmSSOHH'mm`): `Z` for UTC, as pdfcraft stamps every mark it +//! makes, or an offset such as `+02'00'`. [`local`] takes such a date to the +//! wall clock of this device at that instant; a date written without a zone +//! has no known relation to UTC and is taken as written. +//! +//! The device's offset comes from the same place as the shell's status +//! clock (`crates/shell/src/shell/bar.rs`, `refresh_script_utc_offset`): +//! the C library's `localtime_r` (`tm_gmtoff`) on Unix, chrono's `Local` +//! elsewhere. It is asked for the date's own instant, so a date from before +//! a daylight-saving change reads as the clock read it then. Tests fix it +//! ([`with_offset`]). + +#[cfg(test)] +use std::cell::Cell; + +/// A PDF date (`D:20261011003256Z`, `D:20261010143000+02'00'`, +/// `D:20261010143000`; the `D:` may be missing, and everything after the +/// day is optional) as the local time `YYYY-MM-DDTHH:MM`, where +/// `offset_at(utc)` gives the seconds this device's clock is ahead of UTC +/// at the instant `utc` (seconds since the Unix epoch). A date with no zone +/// is taken as written. `None` for anything else: fewer than eight digits, +/// a month, day or time out of range. +pub(crate) fn local(raw: &str, offset_at: impl Fn(i64) -> i64) -> Option { + let s = raw.trim(); + let s = s.strip_prefix("D:").unwrap_or(s); + let end = s.bytes().position(|b| !b.is_ascii_digit()).unwrap_or(s.len()); + let digits = &s.as_bytes()[..end]; + if digits.len() < 8 { + return None; + } + // Fixed-width fields; one the file leaves out is its default (a lone + // digit at the end completes no field). + let field = |from: usize, len: usize, default: i64| -> i64 { + digits.get(from..from + len).map_or(default, |d| d.iter().fold(0, |n, b| n * 10 + i64::from(b - b'0'))) + }; + let (year, month, day) = (field(0, 4, 0), field(4, 2, 1), field(6, 2, 1)); + let (hour, minute, second) = (field(8, 2, 0), field(10, 2, 0), field(12, 2, 0)); + if !(1..=12).contains(&month) || day < 1 || day > days_in_month(year, month) || hour > 23 || minute > 59 || second > 60 { + return None; + } + let written = (year, month, day, hour, minute); + let shown = match zone(&s[end..]) { + // The instant in UTC, then this device's clock at that instant. + Some(zone) => { + let utc = days_from_civil(year, month, day) * 86_400 + hour * 3_600 + minute * 60 + second.min(59) - zone; + let local = utc + offset_at(utc); + let (y, m, d) = civil_from_days(local.div_euclid(86_400)); + let secs = local.rem_euclid(86_400); + (y, m, d, secs / 3_600, secs / 60 % 60) + } + None => written, + }; + let (y, m, d, h, mi) = shown; + Some(format!("{y:04}-{m:02}-{d:02}T{h:02}:{mi:02}")) +} + +/// A PDF date's zone, what follows its digits, as seconds ahead of UTC: +/// `Z` is 0; `+hh'mm'` and `-hh'mm'` (the apostrophes and the minutes +/// optional). `None` when the date names no zone it can be read from. +fn zone(rest: &str) -> Option { + let rest = rest.trim().as_bytes(); + let sign = match rest.first()? { + b'Z' | b'z' => return Some(0), + b'+' => 1, + b'-' => -1, + _ => return None, + }; + let two = |at: usize| -> Option { + match rest.get(at..at + 2)? { + [a, b] if a.is_ascii_digit() && b.is_ascii_digit() => Some(i64::from(a - b'0') * 10 + i64::from(b - b'0')), + _ => None, + } + }; + let hours = two(1)?; + let at = if rest.get(3) == Some(&b'\'') { 4 } else { 3 }; + let minutes = match rest.get(at) { + Some(b) if b.is_ascii_digit() => two(at)?, + _ => 0, + }; + (hours <= 23 && minutes <= 59).then_some(sign * (hours * 3_600 + minutes * 60)) +} + +fn leap(year: i64) -> bool { + year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) +} + +fn days_in_month(year: i64, month: i64) -> i64 { + match month { + 4 | 6 | 9 | 11 => 30, + 2 if leap(year) => 29, + 2 => 28, + _ => 31, + } +} + +/// Days since 1970-01-01 of a proleptic Gregorian date (Howard Hinnant's +/// `days_from_civil`, as pdfcraft's own `pdf_date` counts the other way). +fn days_from_civil(year: i64, month: i64, day: i64) -> i64 { + let y = if month <= 2 { year - 1 } else { year }; + let era = y.div_euclid(400); + let yoe = y - era * 400; + let mp = (month + 9) % 12; + let doy = (153 * mp + 2) / 5 + day - 1; + let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; + era * 146_097 + doe - 719_468 +} + +/// The date `days` after 1970-01-01: (year, month, day). +fn civil_from_days(days: i64) -> (i64, i64, i64) { + let z = days + 719_468; + let era = z.div_euclid(146_097); + let doe = z - era * 146_097; + let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365; + let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); + let mp = (5 * doy + 2) / 153; + let day = doy - (153 * mp + 2) / 5 + 1; + let month = if mp < 10 { mp + 3 } else { mp - 9 }; + (yoe + era * 400 + i64::from(month <= 2), month, day) +} + +#[cfg(test)] +thread_local! { + /// A test's fixed offset ([`with_offset`]). + static FIXED: Cell> = const { Cell::new(None) }; +} + +/// Seconds this device's clock is ahead of UTC at the instant `utc` +/// (module doc); 0 where the C library knows no zone. +pub(crate) fn offset_at(utc: i64) -> i64 { + #[cfg(test)] + if let Some(fixed) = FIXED.with(Cell::get) { + return fixed; + } + device_offset_at(utc) +} + +#[cfg(unix)] +fn device_offset_at(utc: i64) -> i64 { + // A 32-bit `time_t` cannot hold every instant. + let Some(at) = libc::time_t::try_from(utc).ok() else { return 0 }; + // SAFETY: `localtime_r` is the reentrant form: it reads `at` and writes + // only the `tm` it is handed, which lives on this stack. + let mut tm: libc::tm = unsafe { std::mem::zeroed() }; + if unsafe { libc::localtime_r(&at, &mut tm) }.is_null() { + return 0; + } + // A C `long`: 32 bits on some targets, as the shell's clock reads it. + tm.tm_gmtoff as i64 +} + +#[cfg(not(unix))] +fn device_offset_at(utc: i64) -> i64 { + use chrono::TimeZone; + chrono::Local.timestamp_opt(utc, 0).single().map_or(0, |t| i64::from(t.offset().local_minus_utc())) +} + +/// The minute `YYYY-MM-DDTHH:MM` of a clock `offset` seconds ahead of UTC at +/// the instant `utc` (tests: what a mark made then should read as). +#[cfg(test)] +pub(crate) fn minute_at(utc: i64, offset: i64) -> String { + let local = utc + offset; + let (y, m, d) = civil_from_days(local.div_euclid(86_400)); + let secs = local.rem_euclid(86_400); + format!("{y:04}-{m:02}-{d:02}T{:02}:{:02}", secs / 3_600, secs / 60 % 60) +} + +/// Run `f` with this device's offset fixed at `seconds` ahead of UTC, on +/// this thread (a service call in a test runs on the test's thread). +#[cfg(test)] +pub(crate) fn with_offset(seconds: i64, f: impl FnOnce() -> T) -> T { + struct Restore(Option); + impl Drop for Restore { + fn drop(&mut self) { + FIXED.with(|fixed| fixed.set(self.0)); + } + } + let _restore = Restore(FIXED.with(|fixed| fixed.replace(Some(seconds)))); + f() +} + +#[cfg(test)] +mod tests { + use super::*; + + const PDT: i64 = -7 * 3_600; + + #[test] + fn a_utc_date_reads_as_this_devices_clock() { + // The bug: a mark made at 17:32 PDT on 10 Oct is stamped 00:32 UTC + // on 11 Oct, and read as local time, it said "11 Oct". + assert_eq!(local("D:20261011003256Z", |_| PDT).as_deref(), Some("2026-10-10T17:32")); + assert_eq!(local("D:20261011003256Z", |_| 0).as_deref(), Some("2026-10-11T00:32")); + assert_eq!(local("D:20261011003256Z", |_| 5 * 3_600 + 1_800).as_deref(), Some("2026-10-11T06:02"), "a half-hour zone"); + assert_eq!(local("20261011003256Z", |_| PDT).as_deref(), Some("2026-10-10T17:32"), "without the D: prefix"); + assert_eq!(local("D:20261011003256Z00'00'", |_| PDT).as_deref(), Some("2026-10-10T17:32"), "Z with a redundant offset"); + } + + #[test] + fn an_offset_date_reads_as_this_devices_clock() { + assert_eq!(local("D:20261010143000+02'00'", |_| 0).as_deref(), Some("2026-10-10T12:30")); + assert_eq!(local("D:20261010143000+02'00'", |_| PDT).as_deref(), Some("2026-10-10T05:30")); + assert_eq!(local("D:20261010010000+02'00'", |_| PDT).as_deref(), Some("2026-10-09T16:00"), "back across midnight"); + assert_eq!(local("D:20261010220000-04'00'", |_| 2 * 3_600).as_deref(), Some("2026-10-11T04:00"), "forward across midnight"); + assert_eq!(local("D:20261231233000-01'00'", |_| 0).as_deref(), Some("2027-01-01T00:30"), "into the next year"); + assert_eq!(local("D:20240229120000+0530", |_| 0).as_deref(), Some("2024-02-29T06:30"), "no apostrophes"); + assert_eq!(local("D:20261010143000+02'", |_| 0).as_deref(), Some("2026-10-10T12:30"), "hours only"); + assert_eq!(local("D:20261010143000+02", |_| 0).as_deref(), Some("2026-10-10T12:30")); + } + + #[test] + fn a_date_without_a_zone_is_taken_as_written() { + assert_eq!(local("D:20261010143000", |_| PDT).as_deref(), Some("2026-10-10T14:30")); + assert_eq!(local("D:202610101430", |_| PDT).as_deref(), Some("2026-10-10T14:30")); + assert_eq!(local("D:20261010", |_| PDT).as_deref(), Some("2026-10-10T00:00"), "a day alone"); + assert_eq!(local("D:20261010143000 ", |_| PDT).as_deref(), Some("2026-10-10T14:30")); + // A zone that cannot be read is no zone. + assert_eq!(local("D:20261010143000+2", |_| PDT).as_deref(), Some("2026-10-10T14:30")); + assert_eq!(local("D:20261010143000+25'00'", |_| PDT).as_deref(), Some("2026-10-10T14:30")); + assert_eq!(local("D:20261010143000 local", |_| PDT).as_deref(), Some("2026-10-10T14:30")); + } + + #[test] + fn what_is_not_a_date_is_none() { + for raw in ["", "D:", "D:2026", "D:202610", "yesterday", "2026-10-10 14:30", "D:20261310", "D:20260230", "D:20261010246000Z", "D:20261010236000Z"] { + assert_eq!(local(raw, |_| 0), None, "{raw:?}"); + } + assert_eq!(local("D:20240229", |_| 0).as_deref(), Some("2024-02-29T00:00"), "a leap day"); + assert_eq!(local("D:20250229", |_| 0), None, "not a leap year"); + } + + #[test] + fn the_offset_is_the_one_at_the_dates_own_instant() { + // A zone whose offset changes at 2026-11-01T09:00Z, from -7 h to -8 h. + let change = days_from_civil(2026, 11, 1) * 86_400 + 9 * 3_600; + let zone = |utc: i64| if utc < change { -7 * 3_600 } else { -8 * 3_600 }; + assert_eq!(local("D:20261101083000Z", zone).as_deref(), Some("2026-11-01T01:30")); + assert_eq!(local("D:20261101093000Z", zone).as_deref(), Some("2026-11-01T01:30"), "an hour later, the clock went back"); + } + + #[test] + fn civil_days_round_trip() { + assert_eq!(days_from_civil(1970, 1, 1), 0); + assert_eq!(days_from_civil(2026, 10, 11), 20_737); + for days in [-719_468, -1, 0, 59, 60, 11_016, 20_737, 2_932_896] { + let (y, m, d) = civil_from_days(days); + assert_eq!(days_from_civil(y, m, d), days, "{y}-{m}-{d}"); + } + } + + #[test] + fn a_fixed_offset_holds_only_inside_and_this_device_answers_outside() { + let device = offset_at(0); + assert_eq!(with_offset(PDT, || offset_at(0)), PDT); + assert_eq!(with_offset(3_600, || with_offset(PDT, || offset_at(0))), PDT, "the innermost wins"); + assert_eq!(offset_at(0), device, "restored"); + // This device's own offset is a real one, within a day of UTC. + assert!(device.abs() <= 14 * 3_600, "{device}"); + } +} diff --git a/apps/pdf/host-service/src/doc_tests.rs b/apps/pdf/host-service/src/doc_tests.rs index 5e062507..35e0d86c 100644 --- a/apps/pdf/host-service/src/doc_tests.rs +++ b/apps/pdf/host-service/src/doc_tests.rs @@ -679,6 +679,134 @@ fn page_operations_and_text_edits() { coded(&w.err("edit_text", json!({"doc": doc, "page": 3, "line": 999, "text": "x"})), "invalid"); } +/// A page with a heading and a paragraph of three lines in Helvetica, set +/// flush left in black. +fn paragraph_pdf() -> Vec { + let content = "BT /F1 18 Tf 50 360 Td (Third quarter) Tj ET\nBT /F1 12 Tf 14 TL 50 320 Td (The quarter closed ahead of plan, with) Tj T* (revenue up in every region while costs) Tj T* (held flat.) Tj ET"; + let objs = [ + "<< /Type /Catalog /Pages 2 0 R >>".to_string(), + "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string(), + "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 400 400] /Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>".to_string(), + format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len()), + "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".to_string(), + ]; + assemble(&objs) +} + +/// `[x, y, w, h]` from an answer. +fn xywh4(v: &Json) -> [f64; 4] { + let n = |i: usize| v[i].as_f64().unwrap_or_else(|| panic!("not [x, y, w, h]: {v}")); + [n(0), n(1), n(2), n(3)] +} + +/// `pdf.edit_text` formats a paragraph with `align` (left, center, right, +/// justify) and `color` (`#rrggbb`) and nothing else: no font, size or +/// move, and a line takes neither. The paragraph is redrawn where it was, +/// in its own font and size. +#[test] +fn a_paragraph_takes_an_alignment_and_a_colour() { + let w = World::new(); + w.put("para.pdf", ¶graph_pdf()); + let doc = w.open("para.pdf"); + // The paragraph as pdf.lines gives it: its number, text and box, and its + // lines' boxes. + let paragraph = || { + let lines = w.ok("lines", json!({"doc": doc, "page": 1})); + let p = lines["paragraphs"].as_array().unwrap().iter().find(|p| p["text"].as_str().unwrap().starts_with("The quarter")).unwrap_or_else(|| panic!("{lines}")).clone(); + let boxes: Vec<[f64; 4]> = p["lines"] + .as_array() + .unwrap() + .iter() + .map(|n| xywh4(&lines["lines"].as_array().unwrap().iter().find(|l| l["n"] == *n).unwrap()["box"])) + .collect(); + (p["n"].clone(), p["text"].as_str().unwrap().to_string(), xywh4(&p["box"]), boxes) + }; + // Each line's fill colour, as the engine reads the page. + let colours = || { + docs::with_open(&doc, |d| d.engine.session().docs()[0].text_lines(0).iter().filter(|l| !l.text.contains("Third")).map(|l| l.color).collect::>()).unwrap() + }; + let (n, text, [x, _, width, _], boxes) = paragraph(); + assert_eq!(boxes.len(), 3, "three lines"); + assert!(colours().iter().all(|c| c.iter().all(|v| v.abs() < 0.01)), "black: {:?}", colours()); + let near = |a: f64, b: f64| (a - b).abs() < 1.0; + + assert_eq!(w.ok("edit_text", json!({"doc": doc, "page": 1, "paragraph": n, "text": text, "align": "right", "color": "#C0392B"})), json!({"edited": true})); + let (n, after, _, boxes) = paragraph(); + assert_eq!(after, text, "the same words"); + for b in &boxes { + assert!(near(b[0] + b[2], x + width), "flush right at {}: {b:?}", x + width); + } + let red = [0xc0 as f64 / 255.0, 0x39 as f64 / 255.0, 0x2b as f64 / 255.0]; + for c in colours() { + assert!(c.iter().zip(red).all(|(v, r)| (v - r).abs() < 0.01), "#c0392b: {c:?}"); + } + w.ok("edit_text", json!({"doc": doc, "page": 1, "paragraph": n, "text": text, "align": "center"})); + let (n, _, _, boxes) = paragraph(); + for b in &boxes { + assert!(near(b[0] + b[2] / 2.0, x + width / 2.0), "centred on {}: {b:?}", x + width / 2.0); + } + assert!(colours().iter().all(|c| c.iter().zip(red).all(|(v, r)| (v - r).abs() < 0.01)), "an edit without a colour keeps the paragraph's own"); + w.ok("edit_text", json!({"doc": doc, "page": 1, "paragraph": n, "text": text, "align": "justify"})); + let (n, _, _, boxes) = paragraph(); + let (last, full) = boxes.split_last().unwrap(); + for b in full { + assert!(near(b[0], x) && near(b[0] + b[2], x + width), "justified to [{x}, {}]: {b:?}", x + width); + } + assert!(near(last[0], x) && last[0] + last[2] < x + width - 10.0, "the last line stays short: {last:?}"); + w.ok("edit_text", json!({"doc": doc, "page": 1, "paragraph": n, "text": text, "align": "left", "color": "#000000"})); + let (n, _, _, boxes) = paragraph(); + assert!(boxes.iter().all(|b| near(b[0], x)), "flush left: {boxes:?}"); + assert!(colours().iter().all(|c| c.iter().all(|v| v.abs() < 0.01)), "black again: {:?}", colours()); + // Each format is one undo step. + w.ok("undo", json!({"doc": doc})); + assert!(colours().iter().all(|c| c.iter().zip(red).all(|(v, r)| (v - r).abs() < 0.01)), "undone: red again, {:?}", colours()); + w.ok("redo", json!({"doc": doc})); + assert!(colours().iter().all(|c| c.iter().all(|v| v.abs() < 0.01)), "redone: black, {:?}", colours()); + + // What the service refuses, before the engine sees it. + let edits = w.ok("state", json!({"doc": doc})); + let base = json!({"doc": doc, "page": 1, "paragraph": n, "text": text}); + let with = |key: &str, value: Json| { + let mut args = base.clone(); + args[key] = value; + args + }; + for bad in [ + json!({"doc": doc, "page": 1, "line": 2, "text": "x", "align": "center"}), + json!({"doc": doc, "page": 1, "line": 2, "text": "x", "color": "#000000"}), + with("align", json!("middle")), + with("align", json!("Center")), + with("align", json!(1)), + with("color", json!("red")), + with("color", json!("#12345")), + with("color", json!("#1234567")), + with("color", json!("123456")), + with("color", json!("#ggg000")), + with("color", json!([1, 0, 0])), + json!({"doc": doc, "page": 1, "paragraph": n, "align": "center"}), + ] { + coded(&w.err("edit_text", bad.clone()), "invalid"); + } + for (key, value) in [ + ("font", json!("times")), + ("bold", json!(true)), + ("italic", json!(true)), + ("size", json!(20)), + ("underline", json!(true)), + ("line_spacing", json!(2)), + ("char_spacing", json!(1)), + ("scale", json!(120)), + ("dx", json!(10)), + ("dy", json!(10)), + ("width", json!(100)), + ] { + let e = w.err("edit_text", with(key, value)); + coded(&e, "invalid"); + assert!(e.contains(&format!("`{key}` is not one of them")), "{e}"); + } + assert_eq!(w.ok("state", json!({"doc": doc})), edits, "the refusals reached nothing"); +} + #[test] fn undo_and_redo_across_calls() { let w = World::new().samples(); @@ -1006,11 +1134,12 @@ fn the_render_cache_keeps_to_its_byte_cap() { std::fs::File::options().write(true).open(&path).unwrap().set_modified(base + Duration::from_secs(i)).unwrap(); } let keep = root.join("bbbb/1@96.png"); - cache::evict(&root, &keep, 1 << 20, cache::LIMITS); + let dot = dir.path().join(".cache"); + cache::evict(&dot, &keep, 1 << 20, cache::LIMITS); let left: Vec = (0..17).filter(|i| old.join(format!("{i}@96.png")).exists()).collect(); assert_eq!(left, (2..17).collect::>(), "15 MiB stay with the new 1 MiB render; the two oldest went"); // The file cap counts too, under a test's small limits. - cache::evict(&root, &keep, 0, cache::Limits { bytes: u64::MAX, files: 4 }); + cache::evict(&dot, &keep, 0, cache::Limits { bytes: u64::MAX, files: 4, covers: cache::MAX_COVERS }); let left: Vec = (0..17).filter(|i| old.join(format!("{i}@96.png")).exists()).collect(); assert_eq!(left, vec![14, 15, 16]); } @@ -1066,6 +1195,297 @@ fn the_render_cache_never_follows_a_link() { assert_eq!(std::fs::read_dir(w.root.join("accounts/device/library")).unwrap().count(), 1); } +/// `pdf.comments` reads the file's dates once per version of the document: +/// a second call with no change reads nothing again, and an edit, an undo, a +/// redo and a save each make a new version, read once more. +#[test] +fn comment_dates_are_read_once_per_version_of_the_document() { + let w = World::new(); + w.put("dated.pdf", &dated_comments()); + let doc = w.open("dated.pdf"); + let reads = review::date_reads; + let start = reads(); + let first = w.ok("comments", json!({"doc": doc})); + assert_eq!(reads(), start + 1); + assert_eq!(w.ok("comments", json!({"doc": doc})), first, "the same answer"); + assert_eq!(reads(), start + 1, "no change: not read again"); + w.ok("comment", json!({"doc": doc, "op": "add", "page": 1, "type": "note", "at": [200, 200], "text": "new", "author": "Ana"})); + w.ok("comments", json!({"doc": doc})); + assert_eq!(reads(), start + 2, "an edit: read again"); + w.ok("comments", json!({"doc": doc})); + assert_eq!(reads(), start + 2, "and once only"); + w.ok("undo", json!({"doc": doc})); + assert_eq!(w.ok("comments", json!({"doc": doc})), first, "undone: the dates as they were"); + assert_eq!(reads(), start + 3, "an undo: read again"); + w.ok("redo", json!({"doc": doc})); + w.ok("comments", json!({"doc": doc})); + assert_eq!(reads(), start + 4, "a redo: read again"); + w.ok("save", json!({"doc": doc})); + w.ok("comments", json!({"doc": doc})); + assert_eq!(reads(), start + 5, "a save: read again"); + w.ok("comments", json!({"doc": doc})); + assert_eq!(reads(), start + 5); +} + +/// Dates of hostile bytes, characters of more than one byte where a date's +/// digits or its zone go, are read without a panic: a zone that is not one +/// is no zone, and text that is no date stays as the file has it. (Kept +/// clear of byte 12 after `D:`, where the engine's own listing cuts a date: +/// a character across it fails the document's opening, an engine fault.) +#[test] +fn a_hostile_comment_date_is_read_safely() { + let note = |name: &str, top: u32, date: &str| { + format!("<< /Type /Annot /Subtype /Text /Rect [40 {} 60 {top}] /T (Ana) /Contents (about {name}) /M ({date}) /NM ({name}) /P 3 0 R >>", top - 20) + }; + let page = "BT /F1 12 Tf 20 280 Td (Hostile dates) Tj ET"; + let objs = [ + "<< /Type /Catalog /Pages 2 0 R >>".to_string(), + "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string(), + "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] /Resources << /Font << /F1 8 0 R >> >> /Contents 7 0 R /Annots [4 0 R 5 0 R 6 0 R] >>".to_string(), + // é (\351 in PDFDocEncoding, two bytes once decoded) after the hour, + // in the zone, and alone. + note("digits", 260, "D:2026101014\\351\\351Z"), + note("zone", 220, "D:20261010143000+\\351\\351"), + note("text", 180, "\\351\\351\\351"), + format!("<< /Length {} >>\nstream\n{page}\nendstream", page.len()), + "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>".to_string(), + ]; + let w = World::new(); + w.put("hostile.pdf", &assemble(&objs)); + let doc = w.open("hostile.pdf"); + let listed = dates::with_offset(PDT, || dates_of(&w.ok("comments", json!({"doc": doc})))); + let date_of = |id: &str| listed.iter().find(|(i, _)| i == id).map(|(_, d)| d.clone()).unwrap_or_else(|| panic!("no {id}: {listed:?}")); + assert_eq!(date_of("digits"), "2026-10-10T14:00", "the digits there are, no zone"); + assert_eq!(date_of("zone"), "2026-10-10T14:30", "a zone that is not one is no zone"); + assert_eq!(date_of("text"), "\u{e9}\u{e9}\u{e9}", "no date: as the file has it"); +} + +// ------------------------------------------------------------ covers + +/// `pdf.cover`'s file name: `--@.png` in +/// `.cache/covers`, lowercase hex and digits. +#[track_caller] +fn cover_name(path: &str, dpi: u32) -> (String, String) { + let name = path.strip_prefix(".cache/covers/").unwrap_or_else(|| panic!("not a cover: {path}")); + let (key, rest) = name.split_once('@').unwrap(); + assert_eq!(rest, format!("{dpi}.png"), "{name}"); + let parts: Vec<&str> = key.split('-').collect(); + assert_eq!(parts.len(), 3, "{name}"); + assert!(parts[0].len() == 16 && parts[0].bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)), "{name}"); + assert!(parts[1..].iter().all(|p| !p.is_empty() && p.bytes().all(|b| b.is_ascii_digit())), "{name}"); + (parts[0].to_string(), key.to_string()) +} + +/// A cover is page 1 at 48 dpi by default, kept in `.cache/covers` across +/// closes, prunes and releases, and a kept cover answers without opening +/// the PDF at all. +#[test] +fn a_cover_is_kept_across_closes_and_runs() { + let w = World::new().samples(); + let cover = w.ok("cover", json!({"path": "Board minutes.pdf"})); + let path = cover["path"].as_str().unwrap().to_string(); + let (key, _) = cover_name(&path, 48); + assert_eq!(key, covers::name_key("Board minutes.pdf")); + let size = &w.ok("info", json!({"path": "Board minutes.pdf"}))["pages"][0]; + let at_48 = |points: &Json| json!(reading::pixels(points.as_f64().unwrap(), 48)); + assert_eq!((cover["width"].clone(), cover["height"].clone(), cover["dpi"].clone()), (at_48(&size["width"]), at_48(&size["height"]), json!(48)), "page 1 at 48 dpi: {cover}"); + let file = w.root.join(&path); + assert!(std::fs::read(&file).unwrap().starts_with(b"\x89PNG")); + assert_eq!(docs::open_count(), 0, "no open document"); + assert_eq!(w.ok("cover", json!({"path": "Board minutes.pdf"})), cover, "the same cover again"); + + // A document opened, rendered and closed; another opened (which prunes + // the closed one's renders); one released after its idle bound. + let doc = w.open("Board minutes.pdf"); + w.ok("page", json!({"doc": doc, "page": 1})); + w.ok("close", json!({"doc": doc})); + let other = w.open("Field guide.pdf"); + w.ok("page", json!({"doc": other, "page": 1})); + docs::sweep_at(Instant::now() + docs::IDLE + Duration::from_secs(1)); + coded(&w.err("state", json!({"doc": other})), "unknown_doc"); + assert!(!w.root.join(format!(".cache/pages/{other}")).exists(), "the released document's renders went"); + assert!(file.is_file(), "the cover stayed through close, prune and release"); + + // A new run: the same file (its size and time) answers from the cache, + // with no engine work: bytes the engine cannot read, kept the same size + // and time, still answer with the kept cover. + let pdf = w.root.join("Board minutes.pdf"); + let (len, modified) = { let m = std::fs::metadata(&pdf).unwrap(); (m.len(), m.modified().unwrap()) }; + let original = std::fs::read(&pdf).unwrap(); + std::fs::write(&pdf, vec![b'x'; len as usize]).unwrap(); + std::fs::File::options().write(true).open(&pdf).unwrap().set_modified(modified).unwrap(); + assert_eq!(w.ok("cover", json!({"path": "Board minutes.pdf"})), cover, "kept: the PDF was not opened"); + // Changed (another time), it is read again: and is damaged now. + std::fs::File::options().write(true).open(&pdf).unwrap().set_modified(modified + Duration::from_secs(5)).unwrap(); + coded(&w.err("cover", json!({"path": "Board minutes.pdf"})), "damaged"); + std::fs::write(&pdf, original).unwrap(); +} + +/// A changed PDF (saved) gets a new key and a new cover, and its older +/// cover goes, by its name's exact prefix: another PDF's cover stays, and so +/// does a cover of the same version at another dpi. +#[test] +fn a_changed_pdf_gets_a_new_cover_and_the_old_one_goes() { + let w = World::new().samples(); + let before = w.ok("cover", json!({"path": "Board minutes.pdf"})); + let other = w.ok("cover", json!({"path": "Field guide.pdf"})); + assert_ne!(cover_name(before["path"].as_str().unwrap(), 48).0, cover_name(other["path"].as_str().unwrap(), 48).0); + let doc = w.open("Board minutes.pdf"); + w.ok("pages", json!({"doc": doc, "op": "rotate", "pages": [1], "angle": 90})); + w.ok("save", json!({"doc": doc})); + w.ok("close", json!({"doc": doc})); + let after = w.ok("cover", json!({"path": "Board minutes.pdf"})); + let (key, version) = cover_name(after["path"].as_str().unwrap(), 48); + assert_eq!(key, cover_name(before["path"].as_str().unwrap(), 48).0, "the same PDF's name"); + assert_ne!(version, cover_name(before["path"].as_str().unwrap(), 48).1, "another version"); + assert_eq!((after["width"].clone(), after["height"].clone()), (before["height"].clone(), before["width"].clone()), "the new cover shows page 1 turned: {after}"); + assert!(!w.root.join(before["path"].as_str().unwrap()).exists(), "the older cover went"); + assert!(w.root.join(other["path"].as_str().unwrap()).exists(), "another PDF's cover stayed"); + let larger = w.ok("cover", json!({"path": "Board minutes.pdf", "dpi": 96})); + assert!(w.root.join(after["path"].as_str().unwrap()).exists(), "the same version at another dpi stays"); + assert!(w.root.join(larger["path"].as_str().unwrap()).exists()); + assert_eq!(larger["dpi"], 96); +} + +/// Covers keep to their 32 within the render cache's 64 files: past 32, the +/// oldest cover goes; page renders go before covers when the cache is full, +/// and a new cover then takes a page's place, not a cover's. +#[test] +fn covers_keep_to_their_cap_and_page_renders_go_first() { + let base = std::time::SystemTime::now() - Duration::from_secs(3_600); + // Each render written a second after the last: the cache's age order + // does not hang on how finely the file system keeps time. + let age = |w: &World, rel: &str, n: u64| std::fs::File::options().write(true).open(w.root.join(rel)).unwrap().set_modified(base + Duration::from_secs(n)).unwrap(); + let cover = |w: &World, i: usize| -> String { + let name = format!("doc {i:02}.pdf"); + w.put(&name, &tiny_pdf(&format!("first {i}"), "second")); + w.ok("cover", json!({"path": name, "dpi": 24}))["path"].as_str().unwrap().to_string() + }; + let w = World::new(); + let mut made = Vec::new(); + for i in 0..=cache::MAX_COVERS { + let path = cover(&w, i); + age(&w, &path, i as u64); + made.push(path); + } + let kept: Vec = made.iter().map(|p| w.root.join(p).exists()).collect(); + assert!(!kept[0] && kept[1..].iter().all(|k| *k), "the 33rd cover took the oldest's place: {kept:?}"); + assert_eq!(std::fs::read_dir(w.root.join(cache::COVERS)).unwrap().count(), cache::MAX_COVERS); + + // Four covers and page renders past the 64 files: the pages go, oldest + // first, and every cover stays. + let w = World::new(); + let covers: Vec = (0..4).map(|i| { let p = cover(&w, i); age(&w, &p, i as u64); p }).collect(); + let doc = w.open("doc 00.pdf"); + let mut pages = Vec::new(); + for (n, dpi) in (24..=300).step_by(3).take(cache::MAX_FILES + 6).enumerate() { + let path = w.ok("page", json!({"doc": doc, "page": 1, "dpi": dpi}))["path"].as_str().unwrap().to_string(); + age(&w, &path, 100 + n as u64); + pages.push(path); + } + let left = |pages: &[String]| pages.iter().filter(|p| w.root.join(p).exists()).count(); + assert!(covers.iter().all(|p| w.root.join(p).exists()), "every cover stayed"); + assert_eq!(left(&pages), cache::MAX_FILES - covers.len(), "the pages kept to what the covers left"); + assert!(pages[..pages.len() - left(&pages)].iter().all(|p| !w.root.join(p).exists()), "the oldest pages went"); + // A fifth cover with the cache full: the oldest page makes room. + let fifth = cover(&w, 4); + assert!(w.root.join(&fifth).exists() && covers.iter().all(|p| w.root.join(p).exists()), "no cover went"); + assert_eq!(left(&pages), cache::MAX_FILES - covers.len() - 1, "a page made room"); +} + +/// The whole cache, covers too, is cleared before a write would fail with +/// `storage_full:`. +#[test] +fn covers_are_cleared_before_storage_full() { + let roomy = World::new().samples(); + let cover = roomy.ok("cover", json!({"path": "Board minutes.pdf", "dpi": 150}))["path"].as_str().unwrap().to_string(); + let doc = roomy.open("Board minutes.pdf"); + roomy.ok("page", json!({"doc": doc, "page": 1, "dpi": 150})); + let cached: u64 = [cover.clone(), format!(".cache/pages/{doc}/1@150.png")].iter().map(|p| std::fs::metadata(roomy.root.join(p)).unwrap().len()).sum(); + let tight = World { _dir: tempfile::tempdir().unwrap(), root: roomy.root.clone(), areas: resolver(&roomy.root, Some(200)) }; + tight.ok("export", json!({"doc": doc, "kind": "text", "out": "minutes.txt"})); + let text = std::fs::metadata(tight.root.join("minutes.txt")).unwrap().len(); + assert!(text > 200 && text <= 200 + cached, "the export needed the cache's room: {text} bytes"); + assert!(!tight.root.join(&cover).exists(), "the cover went with the page renders"); + // A cover that does not fit what is left fails the same way. + coded(&tight.err("cover", json!({"path": "Field guide.pdf", "dpi": 150})), "storage_full"); +} + +/// A cover is not an open document: it adds nothing to the table and is +/// not refused when a caller has its 8 open. +#[test] +fn a_cover_is_no_open_document() { + let w = World::new().samples(); + let open: Vec = (0..docs::MAX_OPEN).map(|_| w.open("Board minutes.pdf")).collect(); + assert_eq!(docs::open_count(), docs::MAX_OPEN); + coded(&w.err("open", json!({"path": "Field guide.pdf"})), "too_many_open"); + w.ok("cover", json!({"path": "Field guide.pdf"})); + w.ok("cover", json!({"path": "Apartment lease.pdf"})); + assert_eq!(docs::open_count(), docs::MAX_OPEN, "no open-document entry"); + coded(&w.err("open", json!({"path": "Field guide.pdf"})), "too_many_open"); + w.ok("close", json!({"doc": open[0]})); + w.open("Field guide.pdf"); +} + +/// A cover runs no script of the PDF's (a fresh session, JavaScript off), +/// and is refused where `pdf.info` refuses: a missing, damaged or locked +/// PDF, a path outside the storage, a dpi out of 24 to 150, a page past 16 +/// megapixels, a key it does not take; and a cache folder that is a link. +#[test] +fn a_cover_runs_no_script_and_is_refused_where_info_is() { + let w = World::new().samples(); + w.put("form.pdf", &scripted_form()); + let cover = w.ok("cover", json!({"path": "form.pdf"})); + let doc = w.open("form.pdf"); + let page = w.ok("page", json!({"doc": doc, "page": 1, "dpi": 48})); + assert_eq!( + std::fs::read(w.root.join(cover["path"].as_str().unwrap())).unwrap(), + std::fs::read(w.root.join(page["path"].as_str().unwrap())).unwrap(), + "the cover is page 1 as the scripts-off session draws it" + ); + assert_eq!(value(&w.ok("fields", json!({"doc": doc})), "note"), json!("quiet")); + // An XFA form whose initialize script sets qty to 2 on opening, as the + // engine's default session (JavaScript on) runs it: the cover is the form + // as the scripts-off session draws it, not as the script left it. + w.put("xfa.pdf", &pdfcraft_xfa::fixtures::shell(&pdfcraft_xfa::fixtures::scripted_template())); + let png = |rel: &Json| std::fs::read(w.root.join(rel.as_str().unwrap())).unwrap(); + let xfa_cover = png(&w.ok("cover", json!({"path": "xfa.pdf"}))["path"]); + let xfa = w.open("xfa.pdf"); + assert_eq!(xfa_cover, png(&w.ok("page", json!({"doc": xfa, "page": 1, "dpi": 48}))["path"]), "the scripts-off drawing"); + let mut on = Automation::new().with_root(&w.root).unwrap(); + let (d, _) = open(&mut on, "xfa.pdf").unwrap(); + assert_eq!(value(&run(&mut on, "form_fields", &json!({"doc": d})).unwrap(), "qty"), json!("2"), "with JavaScript on, the script runs on opening"); + let live = on.call("page_render", &json!({"doc": d, "page": 1, "dpi": 48})).unwrap(); + let live = live.into_iter().find_map(|c| match c { Content::Png { data, .. } => Some(data), _ => None }).unwrap(); + assert_ne!(live, xfa_cover, "the script's value would have shown on the cover"); + + w.put("locked.pdf", &locked_pdf()); + w.put("huge.pdf", &sized_pdf(2_000.0, 2_000.0)); + coded(&w.err("cover", json!({"path": "missing.pdf"})), "not_found"); + coded(&w.err("cover", json!({"path": "Damaged scan.pdf"})), "damaged"); + coded(&w.err("cover", json!({"path": "locked.pdf"})), "protected"); + coded(&w.err("cover", json!({"path": "huge.pdf", "dpi": 150})), "too_large"); + assert_eq!(w.ok("cover", json!({"path": "huge.pdf", "dpi": 24}))["width"], 667, "a lower dpi fits"); + for bad in [json!({"path": "../elsewhere.pdf"}), json!({"path": "/etc/hosts"}), json!({"path": "Board minutes.pdf", "dpi": 23}), json!({"path": "Board minutes.pdf", "dpi": 151}), json!({})] { + coded(&w.err("cover", bad), "invalid"); + } + for (key, value) in [("page", json!(2)), ("out", json!("cover.png")), ("doc", json!("abc"))] { + let mut args = json!({"path": "Board minutes.pdf"}); + args[key] = value; + let e = w.err("cover", args); + coded(&e, "invalid"); + assert!(e.contains(&format!("`{key}` is not one of them")), "{e}"); + } + // A covers folder that is a link is refused, and nothing is written + // through it. + let w = World::new().samples(); + std::fs::create_dir_all(w.root.join("accounts/device/library")).unwrap(); + std::fs::create_dir_all(w.root.join(".cache")).unwrap(); + std::os::unix::fs::symlink(w.root.join("accounts/device/library"), w.root.join(cache::COVERS)).unwrap(); + coded(&w.err("cover", json!({"path": "Board minutes.pdf"})), "invalid"); + assert_eq!(std::fs::read_dir(w.root.join("accounts/device/library")).unwrap().count(), 0, "nothing written through the link"); +} + // ------------------------------------------------------------ snippets #[test] @@ -1091,14 +1511,138 @@ fn snippets_mark_the_match_within_120_characters() { assert!(s.chars().count() <= reading::SNIPPET && s.starts_with("[[word") && s.ends_with("…]]"), "{s}"); } +/// Seven hours behind UTC: California's clock in October. +const PDT: i64 = -7 * 3_600; + +/// A comment's `date` from what the engine lists and what the file writes: +/// the written date with its zone, when it is the one listed; the listed +/// wall clock as written otherwise. +#[test] +fn pdf_dates_read_as_local_time() { + let pdt = |_: i64| PDT; + let date = |listed: Json, written: Option<&str>| review::date(&listed, written, pdt); + // The bug: the engine stamps a mark made at 17:32 on 10 Oct in + // California as 00:32 UTC on 11 Oct, and lists it as "2026-10-11 00:32". + assert_eq!(date(json!("2026-10-11 00:32"), Some("D:20261011003256Z")), json!("2026-10-10T17:32")); + assert_eq!(date(json!("2026-10-10 14:30"), Some("D:20261010143000+02'00'")), json!("2026-10-10T05:30")); + assert_eq!(date(json!("2026-10-10 14:30"), Some("D:20261010143000")), json!("2026-10-10T14:30"), "no zone: as written"); + // Without the written date, or with one that is not the listed one, the + // listing's wall clock, as written. + assert_eq!(date(json!("2026-10-11 00:32"), None), json!("2026-10-11T00:32")); + assert_eq!(date(json!("2026-10-11 00:32"), Some("D:20261012003256Z")), json!("2026-10-11T00:32")); + // A date the listing passed through (fewer than twelve digits). + assert_eq!(date(json!("D:2026101014Z"), Some("D:2026101014Z")), json!("2026-10-10T07:00")); + assert_eq!(date(json!("D:20261010"), None), json!("2026-10-10T00:00")); + assert_eq!(date(json!("yesterday"), Some("yesterday")), json!("yesterday")); + assert_eq!(date(Json::Null, Some("D:20261011003256Z")), Json::Null); +} + +/// A one-page PDF whose comments and replies carry each kind of date a +/// file writes: UTC (`Z`, as the engine stamps its own marks), an offset +/// (`+02'00'`) and no zone. Comment `a` (UTC) has a reply dated with an +/// offset, `b` (an offset) one with no zone, `c` (no zone) one in UTC, and +/// the last comment has no name (its id is its place) and a western offset. +fn dated_comments() -> Vec { + let note = |name: &str, top: u32, date: &str, extra: &str| { + let nm = if name.is_empty() { String::new() } else { format!(" /NM ({name})") }; + format!("<< /Type /Annot /Subtype /Text /Rect [40 {} 60 {top}] /T (Ana) /Contents (about {name}) /M ({date}){nm}{extra} /P 3 0 R >>", top - 20) + }; + let page = "BT /F1 12 Tf 20 280 Td (Dated comments) Tj ET"; + let objs = [ + "<< /Type /Catalog /Pages 2 0 R >>".to_string(), + "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_string(), + "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] /Resources << /Font << /F1 12 0 R >> >> /Contents 11 0 R /Annots [4 0 R 5 0 R 6 0 R 7 0 R 8 0 R 9 0 R 10 0 R] >>".to_string(), + // 4–6 the comments, 7–9 their replies, 10 the unnamed comment + note("a", 260, "D:20261011003256Z", ""), + note("b", 220, "D:20261010143000+02'00'", ""), + note("c", 180, "D:20261010143000", ""), + note("a-reply", 260, "D:20261011090000+02'00'", " /IRT 4 0 R"), + note("b-reply", 220, "D:20261011090000", " /IRT 5 0 R"), + note("c-reply", 180, "D:20261011003000Z", " /IRT 6 0 R"), + note("", 140, "D:20261011220000-04'00'", ""), + // 11 the page's content, 12 its font + format!("<< /Length {} >>\nstream\n{page}\nendstream", page.len()), + "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>".to_string(), + ]; + assemble(&objs) +} + +/// The dates of `pdf.comments`, as (id, date) of each comment, then +/// (reply id, date) of each reply. +fn dates_of(list: &Json) -> Vec<(String, String)> { + let mut out = Vec::new(); + for c in list["comments"].as_array().unwrap() { + out.push((c["id"].as_str().unwrap().to_string(), c["date"].as_str().unwrap_or("").to_string())); + for r in c["replies"].as_array().unwrap() { + out.push((r["id"].as_str().unwrap().to_string(), r["date"].as_str().unwrap_or("").to_string())); + } + } + out +} + +/// SERVICE.md: a comment's `date` is this device's local time. A date in +/// UTC or with an offset goes to the device's clock, and a date with no +/// zone is taken as written, for comments and replies alike, read from the +/// file's own `/M` (the engine's listing drops the zone). #[test] -fn pdf_dates_read_as_iso_8601() { - assert_eq!(review::date(&json!("2026-10-10 14:30")), json!("2026-10-10T14:30"), "the engine's listing: the file's wall clock"); - assert_eq!(review::date(&json!("D:20261010143000+02'00'")), json!("2026-10-10T14:30:00+02:00")); - assert_eq!(review::date(&json!("D:20261010143000Z")), json!("2026-10-10T14:30:00Z")); - assert_eq!(review::date(&json!("D:20261010")), json!("2026-10-10T00:00:00Z")); - assert_eq!(review::date(&json!("yesterday")), json!("yesterday")); - assert_eq!(review::date(&Json::Null), Json::Null); +fn comment_dates_are_this_devices_local_time() { + let w = World::new(); + w.put("dated.pdf", &dated_comments()); + let doc = w.open("dated.pdf"); + let owned = |pairs: &[(&str, &str)]| pairs.iter().map(|(id, date)| (id.to_string(), date.to_string())).collect::>(); + let in_california = dates::with_offset(PDT, || dates_of(&w.ok("comments", json!({"doc": doc})))); + assert_eq!( + in_california, + owned(&[ + ("a", "2026-10-10T17:32"), + ("a-reply", "2026-10-11T00:00"), + ("b", "2026-10-10T05:30"), + ("b-reply", "2026-10-11T09:00"), + ("c", "2026-10-10T14:30"), + ("c-reply", "2026-10-10T17:30"), + ("@1-7", "2026-10-11T19:00"), + ]) + ); + let in_tokyo = dates::with_offset(9 * 3_600, || dates_of(&w.ok("comments", json!({"doc": doc})))); + assert_eq!( + in_tokyo, + owned(&[ + ("a", "2026-10-11T09:32"), + ("a-reply", "2026-10-11T16:00"), + ("b", "2026-10-10T21:30"), + ("b-reply", "2026-10-11T09:00"), + ("c", "2026-10-10T14:30"), + ("c-reply", "2026-10-11T09:30"), + ("@1-7", "2026-10-12T11:00"), + ]), + "the same file on a clock nine hours ahead of UTC; dates with no zone stay as written" + ); + assert_eq!(w.ok("state", json!({"doc": doc}))["edited"], false, "reading the dates changed nothing"); + + // A mark made now is stamped in UTC by the engine and reads as the + // device's clock now, unsaved and after a save; one in another place + // too (an unnamed comment's id is its place). + let made = |before: i64, after: i64, date: &str| [before, after].iter().any(|t| dates::minute_at(*t, PDT) == date); + let now = || std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() as i64; + let before = now(); + let id = w.ok("comment", json!({"doc": doc, "op": "add", "page": 1, "type": "note", "at": [200, 200], "text": "now", "author": "Ana"}))["id"].as_str().unwrap().to_string(); + w.ok("comment", json!({"doc": doc, "op": "reply", "id": "a", "text": "seen", "author": "Ben"})); + let after = now(); + let list = dates::with_offset(PDT, || w.ok("comments", json!({"doc": doc}))); + let listed = dates_of(&list); + let date_of = |listed: &[(String, String)], id: &str| listed.iter().find(|(i, _)| i == id).map(|(_, d)| d.clone()).unwrap_or_else(|| panic!("no {id}: {listed:?}")); + assert!(made(before, after, &date_of(&listed, &id)), "a new comment, unsaved: {listed:?}"); + let a = list["comments"].as_array().unwrap().iter().find(|c| c["id"] == "a").unwrap(); + let seen = a["replies"].as_array().unwrap().iter().find(|r| r["text"] == "seen").unwrap_or_else(|| panic!("no reply: {a}")); + assert!(made(before, after, seen["date"].as_str().unwrap()), "a new reply, unsaved: {a}"); + assert_eq!(date_of(&listed, "a-reply"), "2026-10-11T00:00", "the reply beside it keeps its own zone"); + w.ok("save", json!({"doc": doc})); + w.ok("close", json!({"doc": doc})); + let again = w.open("dated.pdf"); + let reopened = dates::with_offset(PDT, || dates_of(&w.ok("comments", json!({"doc": again})))); + assert!(made(before, after, &date_of(&reopened, &id)), "saved and opened again: {reopened:?}"); + assert_eq!(date_of(&reopened, "a"), "2026-10-10T17:32"); + assert_eq!(date_of(&reopened, "b-reply"), "2026-10-11T09:00"); } #[test] diff --git a/apps/pdf/host-service/src/docs.rs b/apps/pdf/host-service/src/docs.rs index 3cb587b5..bbf784cb 100644 --- a/apps/pdf/host-service/src/docs.rs +++ b/apps/pdf/host-service/src/docs.rs @@ -49,7 +49,7 @@ use std::collections::HashMap; use std::panic::{catch_unwind, AssertUnwindSafe}; use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicU64, Ordering}; -use std::sync::OnceLock; +use std::sync::{OnceLock, Weak}; use std::time::{Duration, Instant}; use octosense_appstore::makepad_widgets::splash_storage::{self, StorageAccess}; @@ -107,8 +107,16 @@ pub(crate) struct OpenDoc { pub sizes: Vec<[f64; 2]>, /// Renders in the cache, by (page, dpi). pub renders: HashMap<(u64, u32), Rendered>, + /// The comments' dates as the file writes them (`review.rs`), with the + /// working bytes they were read from: the engine swaps those on every + /// edit, undo, redo and save, so a version of the document is read once. + pub dates: Option<(Weak>, WrittenDates)>, } +/// Each comment's and reply's date as the file writes it, by its 1-based page +/// and its 1-based place in the page's `/Annots`. +pub(crate) type WrittenDates = HashMap<(u64, u64), String>; + impl OpenDoc { /// `extra` with this document's engine id: the arguments of a command /// on it. `extra` is built by the service from reviewed values only. @@ -282,6 +290,13 @@ pub(crate) fn open_count() -> usize { DOCS.with(|docs| docs.borrow().open.len()) } +/// Run `f` on the open document whose handle is `handle`, if there is one, +/// to look into the engine's copy of it (tests). +#[cfg(test)] +pub(crate) fn with_open(handle: &str, f: impl FnOnce(&OpenDoc) -> T) -> Option { + DOCS.with(|docs| docs.borrow().open.iter().find(|d| d.handle == handle).map(f)) +} + /// Run `f` while a call holds the table, as a listener reached from inside /// one would find it (tests). #[cfg(test)] @@ -371,6 +386,7 @@ pub(crate) fn open(a: &Json, cx: &Ctx) -> Result { generation: 0, sizes, renders: HashMap::new(), + dates: None, }; let open: Vec = DOCS.with(|docs| { let mut docs = docs.borrow_mut(); diff --git a/apps/pdf/host-service/src/lib.rs b/apps/pdf/host-service/src/lib.rs index cbc65821..32291f68 100644 --- a/apps/pdf/host-service/src/lib.rs +++ b/apps/pdf/host-service/src/lib.rs @@ -5,7 +5,9 @@ //! //! - **Files.** A call that names a `path` is a fresh session that opens //! the file, acts and closes: `info`, `text`, `render`, `merge`, `split`. -//! The system agent's five `pdf.*` tools (`tools.json`) are these. +//! The system agent's five `pdf.*` tools (`tools.json`) are these. PDF +//! Tools' `cover` is one too: a PDF's first page, kept in the render +//! cache across closes ([`covers`]). //! - **Open documents** (PDF Tools v2, `apps/pdftools/design/SERVICE.md`): //! `open` keeps the engine's document, its edits and undo history, //! between calls under a handle that later calls name as `doc`; `close`, @@ -57,6 +59,8 @@ mod args; mod cache; mod change; mod codes; +mod covers; +mod dates; mod docs; mod reading; mod review; @@ -170,6 +174,7 @@ fn dispatch_in(method: &str, args: &Json, cx: &Ctx) -> Result { "render" => render(args, cx.area), "merge" => merge(args, cx.area), "split" => split(args, cx.area), + "cover" => covers::cover(args, cx), "open" => docs::open(args, cx), "close" => docs::close(args, cx), "state" => docs::state(args, cx), diff --git a/apps/pdf/host-service/src/review.rs b/apps/pdf/host-service/src/review.rs index eefac336..e59cc2e0 100644 --- a/apps/pdf/host-service/src/review.rs +++ b/apps/pdf/host-service/src/review.rs @@ -24,14 +24,43 @@ //! (`doc_tests::a_forms_own_scripts_never_run`). //! - `comment_list`, `comment_edit`, `comment_delete`, `comment_reply`, //! `comment_set_status`, `form_fields` and `fill_sign_add` are `safe`. +//! +//! **Dates.** `comment_list` lists a comment's `/M` through pdfcraft-render's +//! `pretty_date`, which keeps the file's wall clock and drops the zone and +//! the seconds: the engine stamps its own marks in UTC +//! (`D:20261011003256Z`), so a mark made at 17:32 in California on 10 Oct +//! listed as 00:32 on 11 Oct. SERVICE.md's `date` is this device's local +//! time, so [`comments`] reads each date as the file writes it from the +//! engine's own comment reader, `pdfcraft_annot::summaries` (the reader +//! the engine's listing comes from), over a `pdfcraft_cos` document opened +//! on the open document's working bytes (its unsaved edits included), and +//! takes it to local time ([`crate::dates`]). That route only reads: the +//! bytes are the engine's own copy in memory (no file is opened, no path +//! named, nothing written), the object reader runs no script and changes +//! nothing, and the session it comes from is borrowed, not called. One pass +//! over the page tree and the comments, the cost of the engine's own +//! listing (the engine's per-comment `comment_props` walks the page tree for +//! each comment), once per version of the document: the dates are kept on +//! the open document with a weak reference to the working bytes they came +//! from, which the engine swaps for new ones on every edit, undo, redo and +//! save. The reference keeps those bytes' address from being reused, not the +//! bytes, so a kept read can only match the version it was read from. A +//! date is used only where it is the one the engine listed for that page +//! and place; otherwise, or if the read fails, the listed wall clock +//! stands, taken as written. -use std::collections::BTreeSet; +use std::collections::{BTreeSet, HashMap}; +use std::panic::{catch_unwind, AssertUnwindSafe}; +use std::sync::{Arc, Weak}; +#[cfg(test)] +use std::cell::Cell; use serde_json::{json, Value as Json}; use crate::args::{self, xywh}; use crate::codes::{self, invalid}; -use crate::docs::{self, OpenDoc}; +use crate::dates; +use crate::docs::{self, OpenDoc, WrittenDates}; use crate::Ctx; /// The comment types `pdf.comment add` makes (SERVICE.md). @@ -62,38 +91,90 @@ fn comment_id(c: &Json) -> Json { } } -/// A comment's date as ISO 8601. The engine lists it as the file's wall -/// clock, `YYYY-MM-DD HH:MM` (pdfcraft-render's `pretty_date`, which drops -/// the seconds and the zone): that becomes `YYYY-MM-DDTHH:MM`, a local -/// time. A raw PDF date (`D:20261010143000+02'00'`) keeps its zone. Any -/// other text stays as the file has it. -pub(crate) fn date(v: &Json) -> Json { - let Some(raw) = v.as_str() else { return Json::Null }; - let b = raw.as_bytes(); +/// A comment's `date` (SERVICE.md: this device's local time, +/// `YYYY-MM-DDTHH:MM`). `listed` is what the engine's `comment_list` gives, +/// the file's wall clock `YYYY-MM-DD HH:MM` without its zone (module doc); +/// `written` is the date as the file writes it, `/M` with its zone, when +/// the service could read it. A written date that is the listed one goes to +/// local time from its zone ([`dates::local`]); without one, the listed wall +/// clock is taken as written. Any other text stays as the file has it. +pub(crate) fn date(listed: &Json, written: Option<&str>, offset_at: impl Fn(i64) -> i64) -> Json { + let Some(listed) = listed.as_str() else { return Json::Null }; + if let Some(local) = written.filter(|w| pretty_date(w) == listed).and_then(|w| dates::local(w, &offset_at)) { + return json!(local); + } + let b = listed.as_bytes(); let digit = |i: usize| b.get(i).is_some_and(u8::is_ascii_digit); if b.len() == 16 && (b[4], b[7], b[10], b[13]) == (b'-', b'-', b' ', b':') && [0, 1, 2, 3, 5, 6, 8, 9, 11, 12, 14, 15].into_iter().all(digit) { - return json!(format!("{}T{}", &raw[..10], &raw[11..])); + return json!(format!("{}T{}", &listed[..10], &listed[11..])); } - let s = raw.strip_prefix("D:").unwrap_or(raw); - let digits: String = s.chars().take_while(char::is_ascii_digit).collect(); - if digits.len() < 8 { - return json!(raw); + // A date the listing passed through unshortened (fewer than twelve + // digits): read as a PDF date. + match dates::local(listed, &offset_at) { + Some(local) => json!(local), + None => json!(listed), } - let part = |from: usize, to: usize, default: &'static str| digits.get(from..to).unwrap_or(default).to_string(); - let (y, mo, d) = (part(0, 4, "0000"), part(4, 6, "01"), part(6, 8, "01")); - let (h, mi, se) = (part(8, 10, "00"), part(10, 12, "00"), part(12, 14, "00")); - let zone = s[digits.len()..].replace('\'', ""); - let zone = match zone.as_bytes().first() { - Some(b'Z') | None => "Z".to_string(), - Some(b'+' | b'-') if zone.len() >= 3 => { - let (sign, rest) = zone.split_at(1); - let hh = rest.get(0..2).unwrap_or("00"); - let mm = rest.get(2..4).unwrap_or("00"); - format!("{sign}{hh}:{mm}") - } - _ => "Z".to_string(), +} + +/// What the engine's listing makes of a written date: pdfcraft-render's +/// `pretty_date` (`D:20261001123000Z` → `2026-10-01 12:30`; anything with +/// fewer than twelve digits after `D:` unchanged), so a written date can be +/// matched with the one listed for the same comment. +fn pretty_date(written: &str) -> String { + let d = written.trim_start_matches("D:"); + let b = d.as_bytes(); + if b.len() >= 12 && b[..12].iter().all(u8::is_ascii_digit) { + format!("{}-{}-{} {}:{}", &d[0..4], &d[4..6], &d[6..8], &d[8..10], &d[10..12]) + } else { + written.to_string() + } +} + +/// Every comment's and reply's date as the file writes it (`/M`), by its +/// 1-based page and its 1-based place in the page's `/Annots` (as the +/// engine's `comment_list` gives `page` and `index`), for the document as it +/// is now: read once per version of it (the module doc), and kept on it. +fn written_dates(doc: &mut OpenDoc) -> &WrittenDates { + let id = doc.id; + let working = doc.engine.session().docs().iter().find(|d| d.id.0 == id).map(|d| (d.bytes.clone(), d.password.clone())); + let kept = match (&doc.dates, &working) { + (Some((seen, _)), Some((bytes, _))) => Weak::ptr_eq(seen, &Arc::downgrade(bytes)), + _ => false, }; - json!(format!("{y}-{mo}-{d}T{h}:{mi}:{se}{zone}")) + if !kept { + let dates = match &working { + Some((bytes, password)) => read_dates(bytes.clone(), password.as_deref()), + None => HashMap::new(), + }; + doc.dates = Some((working.as_ref().map(|(bytes, _)| Arc::downgrade(bytes)).unwrap_or_default(), dates)); + } + &doc.dates.get_or_insert_with(Default::default).1 +} + +#[cfg(test)] +thread_local! { + /// How many times this thread read a document's dates (tests). + static READS: Cell = const { Cell::new(0) }; +} + +/// How many times this thread read a document's dates (tests). +#[cfg(test)] +pub(crate) fn date_reads() -> u32 { + READS.with(Cell::get) +} + +/// The dates of `bytes`, read with the engine's own comment reader: the +/// reviewed read-only route of the module doc. Empty if the document cannot +/// be read so (the engine holds no editor for it either, or a reader fails); +/// a reader's panic stays here. +fn read_dates(bytes: Arc>, password: Option<&str>) -> WrittenDates { + #[cfg(test)] + READS.with(|n| n.set(n.get() + 1)); + catch_unwind(AssertUnwindSafe(|| { + let Ok(cos) = pdfcraft_cos::Document::open_with_password(bytes, password) else { return HashMap::new() }; + pdfcraft_annot::summaries(&cos).into_iter().filter_map(|s| Some(((s.page as u64 + 1, s.index as u64 + 1), s.modified?))).collect() + })) + .unwrap_or_default() } /// The engine's annotation subtype as SERVICE.md's comment type. @@ -120,6 +201,12 @@ pub(crate) fn comments(a: &Json, cx: &Ctx) -> Result { args::only(a, &["doc"], M)?; docs::with_doc(a, cx, M, |doc| { let list = doc.call("comment_list", json!({})).map_err(|e| codes::refused(&e))?; + // Each date with its zone, from the file (module doc). + let written = written_dates(doc); + let when = |c: &Json| { + let at = c["page"].as_u64().zip(c["index"].as_u64()); + date(&c["modified"], at.and_then(|at| written.get(&at)).map(String::as_str), dates::offset_at) + }; let comments: Vec = list["comments"] .as_array() .into_iter() @@ -134,7 +221,7 @@ pub(crate) fn comments(a: &Json, cx: &Ctx) -> Result { "type": kind(&c["type"]), "author": c["author"], "text": c["contents"], - "date": date(&c["modified"]), + "date": when(c), "color": c["color"], "status": c["status"].as_str().map(str::to_ascii_lowercase).unwrap_or_else(|| "none".into()), "rects": if rect.is_null() { json!([]) } else { json!([rect]) }, @@ -142,7 +229,7 @@ pub(crate) fn comments(a: &Json, cx: &Ctx) -> Result { "id": comment_id(r), "author": r["author"], "text": r["contents"], - "date": date(&r["modified"]), + "date": when(r), })).collect::>(), }) }) diff --git a/apps/pdftools/README.md b/apps/pdftools/README.md index a1799af3..7f291ece 100644 --- a/apps/pdftools/README.md +++ b/apps/pdftools/README.md @@ -27,11 +27,11 @@ decision that applies. | --- | --- | | Document tabs | Home while it shows, one tab per open PDF (its name, a dot while it has unsaved changes, a close cross), and Open, which goes to Home | | Mode bar | Read · Comment · Fill & Sign · Pages · Combine · Edit, the current one underlined; Search in document; Undo, Redo; Save | -| Rail and left panel | Pages (thumbnails), Outline (the PDF's bookmarks), Comments, Search (the results); the panel folds away | +| Rail and left panel | Pages (thumbnails), Outline (the PDF's bookmarks), Comments; the panel folds away. A search's results take the panel while it runs (no rail item is lit), and give it back when it ends | | Canvas | The pages, white on the desk: a run of up to eight pages from the page you went to, each the engine's render at screen resolution | -| Pill | Page "3 / 24", previous and next, zoom out, zoom, zoom in, fit width, fit page | +| Pill | Page "3 / 24", previous and next, zoom out, zoom, zoom in, fit width, fit page, and full screen (Read mode); in Read mode, Exit read mode in its place | | Right panel | Comment: the threads. Fill & Sign: the form's fields and Add text, Add date, Add initials. Edit: the paragraph being edited | -| Status line | Saved or Edited, and the storage the PDFs use ("14.6 of 64 MB used", "37 KB of 64 MB used") | +| Status line | Saved or Edited, and what the app's storage holds against what it may hold, from the shell's `files.status` ("14.6 of 64 MB used", "37 KB of 64 MB used") | The designs are drawn at 1536 x 1024, and the manifest asks the desktop to open the window at that size: `"window": {"width": 1536, "height": 1024}`, @@ -59,12 +59,13 @@ page fits the canvas, up to 100%. | --- | --- | --- | | Home | Recent PDFs as cards with their first page, pages, size and when they were opened; Open a PDF from this device (up to 64 MB); remove a PDF (asks once more); an empty state on a first run | `pdf.open`, `pdf.info`, `pdf.page`, `pdf.close` | | Read | Pages render one at a time at 72 dpi x zoom x 2 and are kept; thumbnails fill in one by one; the outline jumps to a section | `pdf.open`, `pdf.page` | -| Find | Search in document, then Return: "12 matches on 7 pages", the results grouped by page with the match in bold, every match highlighted on its page, the current one stronger, previous and next | `pdf.find` | +| Read mode | The pill's full-screen button: the pages alone. The tabs, the mode bar, the rail and both panels, the tool row and the status line give the pages their room, and the pill stays with previous and next, the page, the zoom, fit width and fit page, and Exit read mode. A quiet button at the top right leaves too (a script gets no key events, so there is no Esc). The page and the zoom you chose carry across entering and leaving; a fitted or automatic zoom fits the new canvas. A tap on a page only chooses it | `pdf.page` | +| Find | Search in document, the one way to search, then Return: "12 matches on 7 pages" in the left panel, the results grouped by page with the match in bold, every match highlighted on its page, the current one stronger, previous and next. Done, the results' cross or the field's cross ends the search, and the left panel shows what it did before (Pages if it showed nothing known); a change to the document ends it the same way | `pdf.find` | | Comment | Highlight, Underline or Strike out the line you tap (tap twice for its paragraph), Note and Text box where you tap, in one of four colours; threads with replies, a status, delete. Comments carry the name kept under "Comment as" | `pdf.lines`, `pdf.comments`, `pdf.comment` | | Fill & Sign | The form's fields outlined (required empty ones in red) and listed with their values; choose one to type its value; Add text, Add date and Add initials place a mark where you tap; initials are kept | `pdf.fields`, `pdf.fill`, `pdf.fill_sign` | | Pages | Every page as a large thumbnail: choose pages, Rotate left or right, Delete, Extract (a new PDF in the library), Insert from file (another PDF here), drag a page to move it | `pdf.pages` | -| Combine | This PDF and others in order (drag the grip to reorder), each with its pages ("1-4, 9" or All), "One PDF of 31 pages", a name, Combine; the new PDF opens | `pdf.merge` | -| Edit | Click a paragraph: its text becomes editable in place, the right panel shows its font and size; Apply or Cancel | `pdf.lines`, `pdf.edit_text` | +| Combine | This PDF and others in order (drag the grip to reorder), each with its pages ("1-4, 9" or All), "One PDF of 31 pages", a name, Combine; the new PDF opens. When the list does not fit the window, it scrolls inside the card and the total, name and Combine stay in view | `pdf.merge` | +| Edit | Click a paragraph: its text becomes editable in place; the right panel shows its font and size, its Alignment (left, centre, right or justify: the one its lines show is chosen, since the engine sets an edited paragraph flush left unless told) and its Colour (its own until you pick one of six); Apply or Cancel | `pdf.lines`, `pdf.edit_text` | Undo and Redo use the engine's history; Save writes the PDF back (`pdf.undo`, `pdf.redo`, `pdf.save`, `pdf.state`). Closing a tab with unsaved @@ -97,15 +98,23 @@ engine works in the same folder. | Path | Holds | | --- | --- | | `accounts/device/library/*.pdf` | The PDFs, including imported, extracted and combined ones | -| `accounts/device/library.json` | Per file: title (when not its file name), pages, size, when last opened, the page and zoom it was left at, its cover's render; and `who`: the name comments carry and the initials Fill & Sign places | -| `.cache/pages//@.png` | The engine's page renders: its cache, at most 16 MiB and 64 files | +| `accounts/device/library.json` | Per file: title (when not its file name), pages, size, when last opened, the page and zoom it was left at, its cover; and `who`: the name comments carry and the initials Fill & Sign places | +| `.cache/pages//@.png` | The engine's page renders: its cache, at most 16 MiB and 64 files with the covers | +| `.cache/covers/--@48.png` | Each PDF's cover, page 1 (`pdf.cover`): kept across closes and restarts, drawn again when the PDF changes; at most 32 of the cache's 64 files, and page renders go first | Notes for whoever changes the script: - **Engine work runs on the shell's UI thread (#399).** The app keeps one background render out at a time (`pump()`): the current page and the two after it, then the visible thumbnails, then the rest of the run, then the - other thumbnails, then Home's covers. A change drops only the renders of + other thumbnails, then Home's covers. Once a start, Home asks `pdf.cover` + for each of the first 32 PDFs it shows (the service keeps at most 32): a + kept cover answers from its file alone, a stat and a 24-byte read, and the + picture named in `library.json` shows meanwhile. A cover at a new path is a + PDF that changed (a save), so its pages and size are read again from + `pdf.info`, as they are for a PDF beyond the first 32 that has none. A save + also records the open document's page count, and Remove deletes the + cover. A change drops only the renders of the pages it touched; Undo and Redo, which don't say what changed, redraw the run on show. - **No scroll position for script apps.** The runtime gives a script app no @@ -116,8 +125,9 @@ Notes for whoever changes the script: of pages that starts at that page. Pages before it come back with the pill's previous. - **No keyboard events for script apps.** Every shortcut in the brief (⌘F, - ⌘+ and ⌘−, ⌘0, the arrows, ⌘Z, ⇧⌘Z, ⌘S) is a button instead; Search in - document runs on Return, which a text field does report. + ⌘+ and ⌘−, ⌘0, the arrows, ⌘Z, ⇧⌘Z, ⌘S) is a button instead; ⌘F's is the + Search in document field itself, which runs on Return, the one key a text + field does report. - **State lives on `mod.pdftools`.** A light/dark switch runs the script again (#440); every `let` starts over, `mod` survives, and `resume()` draws every region with the new look. @@ -138,8 +148,9 @@ The library's rules are pure functions in `main.splash`, tested from Rust by evaluating the bundle's functions in a script VM (`crates/shell/src/pdftools_model_tests.rs`): an imported PDF's title, a split part's title, what the library index keeps across a restart, the pages a -range names, a find snippet's match in bold, an avatar's initials and a -comment's date. +range names, a find snippet's match in bold, an avatar's initials, a +comment's date, the storage line's words, a paragraph's alignment read from +its lines, and what an edit sends. ```sh cargo test --locked -p octosense-shell --lib pdftools_model @@ -168,8 +179,8 @@ exceeded` in its log); `--budget-ms 1000` raises the hosts' budget | Run | What it covers | | --- | --- | -| `shell` | Every mode on the samples in the shell's own window, light, then dark through the shell's own style menu (the dark pass works on what the light pass left): Home and its covers, "Open a PDF from this device" refused, reading and thumbnails, find ("9 matches on 4 pages"), a highlight and its reply, a rotation and its undo, combine with a page range ("One PDF of 5 pages"), initials placed by Fill & Sign, a text edit, save, and the damaged file | -| `restart` | The same home again: the library, its titles, the page a PDF was left at, and `Imported PDF.pdf` placed as an import leaves one | +| `shell` | Every mode on the samples in the shell's own window, light, then dark through the shell's own style menu (the dark pass works on what the light pass left): Home and its covers, the status line against the storage's own bytes, "Open a PDF from this device" refused, reading and thumbnails, Read mode (entered from the pill, a page turned and the zoom changed in it, left by Exit read mode or the corner control on that page at that zoom), find ("9 matches on 4 pages") from the top bar alone, with the left panel given back when it ends, a highlight and its reply dated on this machine's clock ("Today 19:42"), a rotation and its undo, combine with a page range ("One PDF of 5 pages"), initials placed by Fill & Sign, a text edit with an alignment and a colour, save, and the damaged file; then one cover per PDF in the cover cache, each in `library.json` | +| `restart` | The same home again: the library, its titles, the page a PDF was left at, `Imported PDF.pdf` placed as an import leaves one, every current cover kept, not drawn again, and a PDF removed from Home taking its kept cover with it | | `full` | Storage filled to 8 KB short of its 64 MiB: the refusal on Home, then a removal, which asks once more | | `empty` | No PDFs: the empty library and its Open button, light and dark | | `missing` | `card-host` with the shipped bundle: no engine and no files service | @@ -209,23 +220,37 @@ that refusal. budget, in the wide layout (an app area of 1292 x 662); and, opened from the shell's menu, a 1296 x 703 window on a 1380 x 845 work area, 32 points above the dock. +- **Verified on 10 and 11 Oct 2026, the follow-ups** (macOS, Apple silicon; + [tests/evidence/v2-followups-20261010](tests/evidence/v2-followups-20261010/README.md)): + the model tests; the `shell`, `restart`, `full` and `empty` runs in a hidden + desktop shell with the real engine, at the window's own size (an app area + of 1292 x 662): comment dates in local time, the Edit panel's Alignment and + Colour, the storage line from `files.status`, covers kept across closes and + a restart and removed with their PDF, Combine's button in view with two + PDFs, one search in the top bar, and Read mode; and the `fixture` run in + card-host at 1536 x 1024. On 10 Oct, before one search and Read mode, those + runs passed at the runtime's 64 ms budget. On 11 Oct they ran with + `--budget-ms 1000`: at 64 ms, under load averages of 54 to 74, the `shell` + run passed every step but overran the budget after UI-thread stalls in the + pdf service's file renames. - **Not verified**: the host's file dialog and a real import (a hidden window cannot open it); with the real engine, form fields, outlines, Redo, the other comment and page operations, password-protected PDFs, the eight-PDF cap and the unsaved-changes question (the dev fixture covers their screens); - the `restart`, `full` and `empty` runs at the window's own size; other - screen sizes; Linux, Windows, phones. -- **Known**: a comment's date is the engine's UTC time read as local time, so - a comment made in the evening west of UTC shows the next day's date, until - the pdf service converts it. The status line counts only the PDFs in the - library: the files service does not report the storage's use. On a heavily - loaded machine a tap can overrun the 64 ms budget and be lost (seen at load - averages of 60 to 150 before `library.json` moved off the tap path). On a - screen 900 points tall the app area is about 1292 x 662. There, with two - PDFs in Combine, the card's Combine button needs one scroll (85 points - short). Home's last caption line (when each PDF was last opened) also sits - at the fold. + other screen sizes; Linux, Windows, phones. +- **Known**: Read mode fills the app's window, not the screen: no app can + make the OctoSense window itself full screen (there is no host API for it), + so maximize the window for the full effect. On a heavily loaded machine a + tap can overrun the 64 ms budget + and be lost (seen at load averages of 60 to 150 before `library.json` moved + off the tap path). The pdf service's file writes run on the UI thread and + count against that budget too (overruns after 262 and 555 ms renames, at + load averages of 54 to 74). On a screen 900 points tall (an app area of about + 1292 x 662), Home's last caption line (when each PDF was last opened) sits + at the fold; the library scrolls. The engine reports neither a + paragraph's alignment nor its colour: the Edit panel reads the alignment + from the lines' boxes and shows the colour as the paragraph's own until you + pick one. - **Not part of this version**: export (no approved design), opening password-protected PDFs, keyboard shortcuts (the runtime gives script apps no - key events), the Edit panel's Alignment and Colour (`pdf.edit_text` takes - only text). + key events). diff --git a/apps/pdftools/README.zh-CN.md b/apps/pdftools/README.zh-CN.md index 29f82e1f..1026fce9 100644 --- a/apps/pdftools/README.zh-CN.md +++ b/apps/pdftools/README.zh-CN.md @@ -23,11 +23,11 @@ craft 引擎只在桌面版中提供（`craft-engines`）。 | --- | --- | | 文档标签 | 显示主页时有 Home 标签，每个打开的 PDF 一个标签（名称、有未保存更改时的圆点、关闭叉号），以及前往主页的 Open | | 模式栏 | Read · Comment · Fill & Sign · Pages · Combine · Edit，当前模式带下划线；Search in document；Undo、Redo；Save | -| 侧栏与左侧面板 | Pages（缩略图）、Outline（PDF 的书签）、Comments、Search（结果）；面板可以收起 | +| 侧栏与左侧面板 | Pages（缩略图）、Outline（PDF 的书签）、Comments；面板可以收起。查找进行时，结果占用左侧面板（侧栏中没有项目高亮），查找结束后交还 | | 画布 | 页面以白色显示在桌面背景上：从你前往的那一页开始的至多八页，每页都是引擎按屏幕分辨率渲染的结果 | -| 浮动控制条 | 页码“3 / 24”、上一页和下一页、缩小、缩放比例、放大、适合宽度、适合页面 | +| 浮动控制条 | 页码“3 / 24”、上一页和下一页、缩小、缩放比例、放大、适合宽度、适合页面，以及全屏（阅读模式）；在阅读模式中，该位置换成 Exit read mode | | 右侧面板 | Comment：评论线程。Fill & Sign：表单字段以及 Add text、Add date、Add initials。Edit：正在编辑的段落 | -| 状态栏 | Saved 或 Edited，以及 PDF 占用的存储（“14.6 of 64 MB used”、“37 KB of 64 MB used”） | +| 状态栏 | Saved 或 Edited，以及应用存储已用多少、最多可用多少，来自 Shell 的 `files.status`（“14.6 of 64 MB used”、“37 KB of 64 MB used”） | 设计图按 1536 x 1024 绘制，清单请求桌面按这个尺寸打开窗口：`"window": {"width": 1536, "height": 1024}`，即 App Hub 的可选窗口提示，需要 `"schema_minor": 1`。桌面会把它限制在自身 @@ -48,12 +48,13 @@ PDF Tools 以 1296 x 703 点打开，应用区域为 1292 x 667，即它的宽 | --- | --- | --- | | 主页 | 最近的 PDF 以卡片显示首页、页数、大小和打开时间；Open a PDF from this device（最大 64 MB）；移除 PDF（会再确认一次）；首次运行时的空状态 | `pdf.open`、`pdf.info`、`pdf.page`、`pdf.close` | | Read | 页面按 72 dpi × 缩放 × 2 逐页渲染并保留；缩略图逐个填入；大纲可跳转到章节 | `pdf.open`、`pdf.page` | -| 查找 | 在 Search in document 中输入后按 Return：“12 matches on 7 pages”，结果按页分组、匹配处加粗，每处匹配在页面上高亮，当前匹配更醒目，可前后切换 | `pdf.find` | +| 阅读模式 | 浮动控制条上的全屏按钮：只显示页面。文档标签、模式栏、侧栏和两侧面板、工具行以及状态栏都让出空间，浮动控制条保留上一页和下一页、页码、缩放、适合宽度、适合页面以及 Exit read mode。右上角一个不显眼的按钮也可以退出（脚本收不到按键事件，因此没有 Esc）。进入和退出时，当前页和你选择的缩放保持不变；适合宽度、适合页面或自动缩放会适应新的画布。在页面上点按只会选中该页 | `pdf.page` | +| 查找 | Search in document 是唯一的查找入口，输入后按 Return：左侧面板显示“12 matches on 7 pages”，结果按页分组、匹配处加粗，每处匹配在页面上高亮，当前匹配更醒目，可前后切换。按 Done、结果面板的关闭按钮或搜索框的清除按钮结束查找后，左侧面板恢复之前显示的内容（之前的内容不明时显示 Pages）；文档发生更改时也以同样方式结束查找 | `pdf.find` | | Comment | 对点按的那一行做高亮、下划线或删除线（点按两次作用于整段），在点按处添加 Note 和 Text box，四种颜色可选；带回复、状态和删除的评论线程。评论使用在“Comment as”中保存的名字 | `pdf.lines`、`pdf.comments`、`pdf.comment` | | Fill & Sign | 用框线标出表单字段（未填的必填字段为红色）并列出其值；选中一个字段即可输入值；Add text、Add date 和 Add initials 会在点按处放置标记；姓名缩写会被保存 | `pdf.fields`、`pdf.fill`、`pdf.fill_sign` | | Pages | 每页一张大缩略图：选择页面，向左或向右旋转、删除、提取（在资料库中生成新 PDF）、从文件插入（这里的另一个 PDF），拖动页面以移动 | `pdf.pages` | -| Combine | 当前 PDF 与其他 PDF 按顺序排列（拖动手柄调整顺序），每个都可指定页面（“1-4, 9”或 All），“One PDF of 31 pages”，名称，Combine；新 PDF 随即打开 | `pdf.merge` | -| Edit | 点击一个段落：它的文字可以就地编辑，右侧面板显示字体和字号；Apply 或 Cancel | `pdf.lines`、`pdf.edit_text` | +| Combine | 当前 PDF 与其他 PDF 按顺序排列（拖动手柄调整顺序），每个都可指定页面（“1-4, 9”或 All），“One PDF of 31 pages”，名称，Combine；新 PDF 随即打开。列表放不下时在卡片内滚动，总页数、名称和 Combine 保持可见 | `pdf.merge` | +| Edit | 点击一个段落：它的文字可以就地编辑；右侧面板显示字体和字号、Alignment（左对齐、居中、右对齐或两端对齐：默认选中各行所显示的那种，因为引擎在未指定时会把编辑后的段落设为左对齐）和 Colour（在选择六种颜色之一前保持段落原有颜色）；Apply 或 Cancel | `pdf.lines`、`pdf.edit_text` | Undo 和 Redo 使用引擎的历史记录；Save 把 PDF 写回（`pdf.undo`、`pdf.redo`、`pdf.save`、 `pdf.state`）。关闭有未保存更改的标签时会询问：Save、Don't save 或 Cancel。 @@ -79,21 +80,27 @@ PDF to make room”）、已打开八个 PDF、关闭时有未保存的更改， | 路径 | 内容 | | --- | --- | | `accounts/device/library/*.pdf` | 所有 PDF，包括导入、提取和合并得到的 | -| `accounts/device/library.json` | 每个文件的标题（与文件名不同时）、页数、大小、上次打开时间、离开时所在的页面和缩放比例、封面的渲染结果；以及 `who`：评论使用的名字和 Fill & Sign 放置的姓名缩写 | -| `.cache/pages//@.png` | 引擎的页面渲染结果：它的缓存，最多 16 MiB、64 个文件 | +| `accounts/device/library.json` | 每个文件的标题（与文件名不同时）、页数、大小、上次打开时间、离开时所在的页面和缩放比例、封面；以及 `who`：评论使用的名字和 Fill & Sign 放置的姓名缩写 | +| `.cache/pages//@.png` | 引擎的页面渲染结果：它的缓存，与封面合计最多 16 MiB、64 个文件 | +| `.cache/covers/--@48.png` | 每个 PDF 的封面，即第 1 页（`pdf.cover`）：关闭和重启后仍保留，PDF 改变后重新绘制；最多占缓存 64 个文件中的 32 个，空间不足时先移除页面渲染 | 给修改脚本的人的说明： - **引擎工作在 Shell 的 UI 线程上运行（#399）。** 应用同时只发出一个后台渲染 （`pump()`）：先是当前页及其后两页，然后是可见的缩略图，然后是这一组页面中的其余页面， - 再是其他缩略图，最后是主页的封面。一处更改只丢弃它所涉及页面的渲染结果；Undo 和 Redo + 再是其他缩略图，最后是主页的封面。每次启动时，主页为它显示的前 32 个 PDF 各请求一次 + `pdf.cover`（服务最多保留 32 个封面）：已保留的封面只凭文件作答（一次 stat 和读取 24 字节）， + 在此期间先显示 `library.json` 中记下的图片。封面换了路径，说明 PDF 已经改变（例如保存过）， + 因此会从 `pdf.info` 重新读取页数和大小；前 32 个以外、还没有这些信息的 PDF 也这样读取。保存时 + 还会记下打开的文档的页数，移除会删除封面。一处更改只丢弃它所涉及页面的渲染结果；Undo 和 Redo 不说明改了什么，因此重新绘制当前显示的那一组页面。 - **脚本应用拿不到滚动位置。** 运行时不给脚本应用读取或设置滚动视图位置的方法。所以画布是 一个静态的 `ScrollXYView`，在渲染结果陆续到达时保持位置不变；前往某一页（缩略图、大纲、 查找结果、浮动控制条）时，先把画布绘制成空的一帧，使其滚动位置被限制回顶部，再填入从该页 开始的一组页面。该页之前的页面可以用浮动控制条的上一页回去。 - **脚本应用收不到键盘事件。** 需求中列出的每个快捷键（⌘F、⌘+ 和 ⌘−、⌘0、方向键、⌘Z、 - ⇧⌘Z、⌘S）都改为按钮；Search in document 在按 Return 时执行，这是文本框会报告的事件。 + ⇧⌘Z、⌘S）都改为按钮；⌘F 对应的就是 Search in document 搜索框本身，它在按 Return 时执行， + 这是文本框唯一会报告的按键。 - **状态保存在 `mod.pdftools` 上。** 切换浅色/深色会重新运行脚本（#440）；每个 `let` 都会 重新开始，`mod` 保留下来，`resume()` 用新的外观重新绘制每个区域。 - **在这个运行时中，Label 会把自己的 margin 和 padding 绘制两次** @@ -110,8 +117,8 @@ PDF to make room”）、已打开八个 PDF、关闭时有未保存的更改， 资料库的规则是 `main.splash` 中的纯函数，由 Rust 在脚本虚拟机中执行包内函数来测试 （`crates/shell/src/pdftools_model_tests.rs`）：导入的 PDF 的标题、拆分出的部分的标题、 -资料库索引在重启后保留的内容、页面范围所指的页面、查找摘要中加粗的匹配、头像中的姓名缩写， -以及评论的日期。 +资料库索引在重启后保留的内容、页面范围所指的页面、查找摘要中加粗的匹配、头像中的姓名缩写、 +评论的日期、状态栏的存储用量文字、从各行读出的段落对齐方式，以及一次编辑发送的内容。 ```sh cargo test --locked -p octosense-shell --lib pdftools_model @@ -137,8 +144,8 @@ python3 apps/pdftools/tests/ui.py --card-host /target/release/card-host | 运行 | 覆盖内容 | | --- | --- | -| `shell` | 在 Shell 自己的窗口中、在示例上覆盖每种模式，先浅色，再通过 Shell 自己的样式菜单切到深色（深色这一轮在浅色一轮留下的状态上进行）：主页及其封面、“Open a PDF from this device”被拒绝、阅读和缩略图、查找（“9 matches on 4 pages”）、一处高亮及其回复、一次旋转及其撤销、带页面范围的合并（“One PDF of 5 pages”）、Fill & Sign 放置的姓名缩写、一次文字编辑、保存，以及损坏的文件 | -| `restart` | 再次使用同一个主目录：资料库、其中的标题、PDF 离开时所在的页面，以及按导入方式放入的 `Imported PDF.pdf` | +| `shell` | 在 Shell 自己的窗口中、在示例上覆盖每种模式，先浅色，再通过 Shell 自己的样式菜单切到深色（深色这一轮在浅色一轮留下的状态上进行）：主页及其封面、状态栏与存储实际字节数相符、“Open a PDF from this device”被拒绝、阅读和缩略图、阅读模式（从浮动控制条进入，在其中翻页并改变缩放，再用 Exit read mode 或右上角按钮退出，回到同一页、同一缩放）、只用顶栏的查找（“9 matches on 4 pages”，结束时交还左侧面板）、一处高亮及其回复（日期按本机时钟显示，如“Today 19:42”）、一次旋转及其撤销、带页面范围的合并（“One PDF of 5 pages”）、Fill & Sign 放置的姓名缩写、一次带对齐方式和颜色的文字编辑、保存，以及损坏的文件；之后检查封面缓存中每个 PDF 只有一个封面，且都记在 `library.json` 中 | +| `restart` | 再次使用同一个主目录：资料库、其中的标题、PDF 离开时所在的页面、按导入方式放入的 `Imported PDF.pdf`、所有当前封面都被保留且没有重新绘制，以及从主页移除的 PDF 连同其保留的封面一起删除 | | `full` | 存储被填到距 64 MiB 只差 8 KB：主页上的拒绝提示，然后移除一个 PDF（会再确认一次） | | `empty` | 没有 PDF：空资料库及其 Open 按钮，浅色和深色 | | `missing` | 使用发布包的 `card-host`：没有引擎，也没有文件服务 | @@ -170,15 +177,27 @@ python3 apps/pdftools/dev-fixture/make_fixture.py /os.pdftoo [tests/evidence/window-20261010](tests/evidence/window-20261010/README.zh-CN.md)）：使用真实 引擎、按运行时 64 ms 的预算，以宽布局（应用区域 1292 x 662）进行的 `shell` 运行，浅色和深色； 以及从 Shell 菜单打开时，在 1380 x 845 的工作区上打开的 1296 x 703 窗口，距程序坞 32 点。 +- **已于 2026 年 10 月 10 日和 11 日验证后续改进**（macOS，Apple 芯片； + [tests/evidence/v2-followups-20261010](tests/evidence/v2-followups-20261010/README.zh-CN.md)）： + 模型测试；在隐藏的桌面 Shell 中使用真实引擎、在窗口自身尺寸（应用区域 1292 x 662）下进行的 + `shell`、`restart`、`full` 和 `empty` 运行：按本地时间显示的评论日期、Edit 面板的 Alignment + 和 Colour、来自 `files.status` 的状态栏存储用量、关闭和重启后仍保留并随 PDF 一起移除的封面、 + 列出两个 PDF 时合并按钮保持可见、只在顶栏的搜索，以及阅读模式；以及在 card-host 中按 + 1536 x 1024 进行的 `fixture` 运行。10 月 10 日（加入顶栏搜索和阅读模式之前），这些运行按 + 运行时 64 ms 的预算通过。10 月 11 日它们使用 `--budget-ms 1000`：在 64 ms 下、54 到 74 的 + 平均负载中，`shell` 运行通过了每个步骤，但在 pdf 服务的文件重命名造成 UI 线程停顿之后超出了 + 预算。 - **未验证**：宿主的文件对话框和真实的导入（隐藏窗口无法打开它）；使用真实引擎时的表单 字段、大纲、Redo、其他评论和页面操作、受密码保护的 PDF、八个 PDF 的上限以及未保存更改 - 的询问（开发夹具覆盖了它们的界面）；窗口自身尺寸下的 `restart`、`full` 和 `empty` 运行； - 其他屏幕尺寸；Linux、Windows、手机。 -- **已知问题**：评论的日期是引擎的 UTC 时间被当作本地时间读取，因此在 UTC 以西的晚上做的 - 评论会显示第二天的日期，直到 pdf 服务完成转换。状态栏只统计资料库中的 PDF：文件服务不 - 报告存储的用量。在负载很高的机器上，一次点按可能超出 64 ms 预算而丢失（在 `library.json` - 移出点按路径之前，于 60 到 150 的平均负载下见到过）。在 900 点高的屏幕上，应用区域约为 - 1292 x 662：合并中列出两个 PDF 时，卡片的 Combine 按钮需要滚动一次才能看到（差 85 点）， - 首页卡片的最后一行说明（每个 PDF 上次打开的时间）正好在可见区域边缘。 + 的询问（开发夹具覆盖了它们的界面）；其他屏幕尺寸；Linux、Windows、手机。 +- **已知问题**：阅读模式占满的是应用窗口，而不是整个屏幕：应用无法让 OctoSense 窗口本身全屏 + （没有相应的宿主 API），想要完整效果请将窗口最大化。在负载很高的机器上，一次点按可能超出 + 64 ms 预算而丢失（在 `library.json` + 移出点按路径之前，于 60 到 150 的平均负载下见到过）。pdf 服务的文件写入在 UI 线程上运行， + 也计入这个预算（在 54 到 74 的平均负载下，曾在 262 ms 和 555 ms 的重命名之后超出预算）。在 900 点高的屏幕上（应用区域约为 + 1292 x 662），首页卡片的最后一行说明（每个 PDF 上次打开的时间）正好在可见区域边缘；资料库 + 可以滚动。引擎既不报告段落的 + 对齐方式，也不报告它的颜色：Edit 面板从各行的边框读出对齐方式，并在选择颜色之前把颜色显示为 + 段落原有的颜色。 - **不在这个版本中**：导出（没有已批准的设计）、打开受密码保护的 PDF、键盘快捷键（运行时 - 不给脚本应用按键事件）、Edit 面板中的 Alignment 和 Colour（`pdf.edit_text` 只接收文字）。 + 不给脚本应用按键事件）。 diff --git a/apps/pdftools/bundle/icons/align-center.svg b/apps/pdftools/bundle/icons/align-center.svg new file mode 100644 index 00000000..600feae4 --- /dev/null +++ b/apps/pdftools/bundle/icons/align-center.svg @@ -0,0 +1 @@ + diff --git a/apps/pdftools/bundle/icons/align-justify.svg b/apps/pdftools/bundle/icons/align-justify.svg new file mode 100644 index 00000000..ec9f579a --- /dev/null +++ b/apps/pdftools/bundle/icons/align-justify.svg @@ -0,0 +1 @@ + diff --git a/apps/pdftools/bundle/icons/align-left.svg b/apps/pdftools/bundle/icons/align-left.svg new file mode 100644 index 00000000..e2704337 --- /dev/null +++ b/apps/pdftools/bundle/icons/align-left.svg @@ -0,0 +1 @@ + diff --git a/apps/pdftools/bundle/icons/align-right.svg b/apps/pdftools/bundle/icons/align-right.svg new file mode 100644 index 00000000..5ea8f3ee --- /dev/null +++ b/apps/pdftools/bundle/icons/align-right.svg @@ -0,0 +1 @@ + diff --git a/apps/pdftools/bundle/icons/fullscreen-exit.svg b/apps/pdftools/bundle/icons/fullscreen-exit.svg new file mode 100644 index 00000000..d9a7ef7c --- /dev/null +++ b/apps/pdftools/bundle/icons/fullscreen-exit.svg @@ -0,0 +1 @@ + diff --git a/apps/pdftools/bundle/icons/fullscreen.svg b/apps/pdftools/bundle/icons/fullscreen.svg new file mode 100644 index 00000000..6b716065 --- /dev/null +++ b/apps/pdftools/bundle/icons/fullscreen.svg @@ -0,0 +1 @@ + diff --git a/apps/pdftools/bundle/main.splash b/apps/pdftools/bundle/main.splash index 54b690de..de774609 100644 --- a/apps/pdftools/bundle/main.splash +++ b/apps/pdftools/bundle/main.splash @@ -66,7 +66,9 @@ let INDEX = "accounts/device/library.json" let CACHE = ".cache/pages" // What an imported PDF is called: the import names its destination first. let IMPORT_NAME = "Imported PDF" -// The app's storage: App Hub's system ceiling (no storage.max_bytes). +// The app's storage: App Hub's system ceiling (no storage.max_bytes). The +// status line reads the real numbers from files.status; this is for a host +// that doesn't say. let QUOTA = 67108864 // What the pdf service allows: 8 open documents, 2 to 16 files per merge, // 512 pages named in one call. @@ -100,6 +102,14 @@ let PAGE_GAP = 13 // Comment colours: the four dots of the Comment tool row. let MARKS = ["yellow", "green", "blue", "pink"] let MARK_HEX = {yellow: "#ffd84d" green: "#5cb85c" blue: "#2d7ff9" pink: "#f0609e"} +// The Edit panel's text colours (design 08), as pdf.edit_text takes them, +// and its alignments, as it names them (SERVICE.md "Edit"). +let TEXT_COLOURS = [{name: "Black" hex: "#000000"}, {name: "Dark grey" hex: "#4b4f54"}, {name: "Blue" hex: "#1a5fb4"}, {name: "Red" hex: "#c01c28"}, {name: "Green" hex: "#26a269"}, {name: "Orange" hex: "#e66100"}] +let ALIGNS = ["left", "center", "right", "justify"] +// The rail (02-reading): Pages, Outline and Comments. Search lives in the top +// bar alone ("Search in document"): its results take the left panel while a +// search runs, and give it back when the search ends. +let RAIL = [{id: "pages" icon: "page" label: "Pages"}, {id: "outline" icon: "outline" label: "Outline"}, {id: "comments" icon: "comment" label: "Comments"}] let MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] let MONTH_NAMES = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"] @@ -130,13 +140,21 @@ fn size_text(bytes){ if bytes < 1048576 { return "" + round(bytes / 1024) + " KB" } "" + floor(bytes / 104857.6) / 10 + " MB" } -// "14.6 of 64 MB used": the PDFs, against the app's storage. -// Under 1 MB it counts in kilobytes ("90 KB of 64 MB used"). -fn used_text(bytes){ - let quota_part = " of " + round(QUOTA / 1048576) + " MB used" +// "14.6 of 64 MB used": what the app's storage holds, against what it may +// hold. Under 1 MB it counts in kilobytes ("90 KB of 64 MB used"). +fn used_text(bytes, quota){ + let quota_part = " of " + round(quota / 1048576) + " MB used" if bytes < 1048576 { return size_text(bytes) + quota_part } "" + floor(bytes / 104857.6) / 10 + quota_part } +// What files.status says the app's storage holds and may hold, or nil when +// it doesn't say (no storage, or a shell from before it did). +fn usage_from(data){ + let used = optional(data, "used_bytes", nil) + let quota = optional(data, "quota_bytes", nil) + if used == nil || quota == nil || quota <= 0 { return nil } + {used: used quota: quota} +} // A library row: the file, and what the index kept about it (`known`, or // nil): its pages and size, its title (otherwise its name), when it was last @@ -243,8 +261,11 @@ fn day_text(t, now_t){ "" + a.day + " " + MONTHS[a.month - 1] + " " + a.year } fn two(n){ pick(n < 10, "0" + n, "" + n) } -// A comment's date as the engine reports it (a PDF date "D:20261010101200", -// or ISO "2026-10-10T10:12"), as Unix seconds in local time, or nil. +// A comment's date as the service reports it, this device's local time +// ("2026-10-10T10:12"; SERVICE.md "Comments": it reads the date the file +// writes and converts it from its zone), as its parts, or nil when the file +// wrote something else (shown as it is). A PDF date the service passed on +// ("D:20261010101200") reads the same way. fn comment_time(date){ let s = "" + date let m = regex("^D?:?([0-9][0-9][0-9][0-9])-?([0-9][0-9])-?([0-9][0-9])[T ]?([0-9][0-9])?:?([0-9][0-9])?").exec(s) @@ -269,6 +290,116 @@ fn date_text(t){ "" + a.day + " " + MONTH_NAMES[a.month - 1] + " " + a.year } +// How far apart the smallest and largest of `values` are. +fn spread(values){ + if values.len() == 0 { return 0 } + let lo = values[0] + let hi = values[0] + for v in values { + lo = min(lo, v) + hi = max(hi, v) + } + hi - lo +} +// A paragraph's alignment as its lines show it, for the Edit panel's +// Alignment: `boxes` are its lines' [x, y, w, h] from pdf.lines, top to +// bottom. Lines that start together are flush left, or justified when every +// line but the last also ends together (three lines at least: two might +// just happen to); lines centred on one point are centred, and lines that +// end together flush right. The engine reports no alignment and sets an +// edited paragraph flush left unless told otherwise (SERVICE.md "Edit"), so +// an edit sends what this finds unless the person picks another. +fn guess_align(boxes){ + if boxes.len() < 2 { return "left" } + let lefts = [] + let rights = [] + let centres = [] + for b in boxes { + lefts.push(b[0]) + rights.push(b[0] + b[2]) + centres.push(b[0] + b[2] / 2) + } + if spread(lefts) <= 1.5 { + let full = [] + for i r in rights { if i < rights.len() - 1 { full.push(r) } } + if boxes.len() >= 3 && spread(full) <= 1.5 { return "justify" } + return "left" + } + if spread(centres) <= 1.5 { return "center" } + if spread(rights) <= 1.5 { return "right" } + "left" +} +// pdf.edit_text's arguments for the paragraph edit `e`: its text and its +// alignment always (the engine sets a paragraph flush left when none is +// named), its colour only when the person chose one. +fn edit_args(doc, e){ + let args = {doc: doc page: e.page paragraph: e.n text: e.draft align: e.align} + if e.color != nil { args.color = e.color } + args +} +// The Combine card's list in points (design 06's measures): each PDF's row +// (113) and its line, the Add files row (60), and, while it is open, the +// list of PDFs to add (`adding_rows`, each 38 and a gap), in a box with a +// border. +fn combine_list_h(items, adding_rows){ + let h = items * 114 + 60 + 2 + if adding_rows > 0 { h = h + 10 + adding_rows * 40 } + h +} +// Whether a Combine card with a list `list_h` tall fits an app `height` +// tall as designed: below the tab row, the mode bar and above the status +// line, within the card's margins (42 and 40), beside its own padding, +// title, the total, Name, a refusal (`error`) and the button (279, and 30). +// When it does not, the list scrolls inside the card and the rest stays. +fn combine_fits(list_h, height, error){ + list_h <= height - TAB_H - MODE_H - STATUS_H - 82 - 279 - pick(error, 30, 0) +} +// Whether the edit `e` changes anything: its text, alignment or colour. +fn edit_changes(e){ e.draft != e.text || e.align != e.align0 || e.color != nil } +// The left side a search gives back when it ends: what it showed before the +// results took it (a panel, or "" when it was folded away), else Pages. +fn panel_after_find(from){ + if from == "" || from == "pages" || from == "outline" || from == "comments" { return from } + "pages" +} +// Whether rail item `id` is lit: Pages in the Pages mode; otherwise the open +// left panel's own item, so none while the panel shows search results. +fn rail_lit(id, mode, panel, open){ + if mode == "pages" { return id == "pages" } + open && panel == id +} +// Read mode (the user: "there is no full screen read mode?"): which of the +// document's regions show. In Read mode, the pages alone with the floating +// bar, and the corner control that leaves it; the window stays the window, +// since no app can make it full screen. +fn chrome_for(reading){ + {tabs: !reading modebar: !reading rail: !reading panels: !reading right: !reading toolrow: !reading status: !reading exit: reading} +} +// The canvas a document's pages get, in points: the window less the rail, +// the left panel (`left`, with its line; 0 when folded), the right panel +// (`right`, likewise), the tab row, the mode bar and the status line; in +// Read mode, the whole window. +fn canvas_size(width, height, reading, left, right){ + if reading { return [max(240, width), max(240, height)] } + [max(240, width - RAIL_W - 1 - left - right), max(240, height - TAB_H - MODE_H - STATUS_H - 2)] +} +// The zoom a document takes when its canvas changes (entering or leaving +// Read mode): a fitted zoom fits the new canvas (`fit_w` and `fit_p` are the +// fits there), the automatic one is worked out again (`start`), and a zoom +// the person chose stays. +fn kept_zoom(zoom, zoom_auto, fit, fit_w, fit_p, start){ + if fit == "width" { return clamp(floor(fit_w * 100) / 100, 0.25, 4.0) } + if fit == "page" { return clamp(floor(fit_p * 100) / 100, 0.25, 4.0) } + if zoom_auto { return start } + zoom +} +// A text colour's name in the Edit panel: "Its own colour" until one is chosen. +fn colour_name(hex){ + if hex == nil { return "Its own colour" } + for c in TEXT_COLOURS { if c.hex == hex { return c.name } } + hex +} + start_timeout(0.05, || boot()) // ---- appearance ----------------------------------------------------------- @@ -290,6 +421,8 @@ let pt_head = if ui_light { #xffffff } else { #x1f262b } let pt_desk = if ui_light { #xeceded } else { #x191f24 } let pt_status = if ui_light { #xffffff } else { #x1b2226 } let pt_pill = if ui_light { #xffffff } else { #x282d32 } +// Read mode's corner control: the bar's colour, a little see-through. +let pt_corner = if ui_light { #xffffffd0 } else { #x282d32d0 } let pt_card = if ui_light { #xffffff } else { #x232a2e } let pt_card_top = if ui_light { #xf7f8f9 } else { #x1e252a } let pt_home = if ui_light { #xf7f8f9 } else { #x191f24 } @@ -378,6 +511,9 @@ if st == nil { files_known: false // files.status answered files_ok: false // this device copies a chosen file in max_import: 0 + used: -1 // what the app's storage holds (files.status); -1 until it says + quota: 0 // and what it may hold + storage_due: false // a files.status question is on its way importing: false alert: nil // {head detail note}: why something failed, on Home space_full: false // the last write found no room @@ -496,6 +632,7 @@ fn storage_full(e){ // Every engine write: a refusal for room shows until a write succeeds or a // PDF is removed. fn wrote(a){ + storage_later() if a.is_ok { st.space_full = false return } if storage_full(a.error) { st.space_full = true } } @@ -624,7 +761,10 @@ fn remove_doc(d){ render_home() return } + // Its cover, kept in the pdf service's cache folder, goes with it. + if d.cover.search(".cache/covers/") == 0 { try { fs.remove(d.cover) } catch {} } forget(d.name) + storage_later() st.space_full = false scan_library() render_home() @@ -672,77 +812,108 @@ fn opened_text(d, days){ "Opened " + a.day + " " + MONTHS[a.month - 1] + " " + a.year } -// Each PDF's pages, size and first page, one engine call at a time. +// Each PDF's cover (its first page) and its pages and size, one engine call +// at a time. Once a start, Home asks pdf.cover for each of the first +// SHOWN_COVERS PDFs it shows: the service keeps at most that many covers, and +// asking for more would evict the ones Home shows first. A kept cover answers +// from its file alone (a stat and a 24-byte read), and the picture kept in +// library.json shows meanwhile. A cover at another path is a PDF that +// changed since (a save, a replacement): its pages and size are read again +// (pdf.info), as they are for a PDF beyond the first ones that has none. +let SHOWN_COVERS = 32 fn cover_next(){ if st.busy || st.engine == "missing" || st.engine == "old" { return false } - for d in st.docs { - if optional(st.covers, d.name, nil) == nil && optional(st.cover_tried, d.name, nil) == nil && d.error == "" && !d.locked { - read_cover(d) - return true + for i d in st.docs { + if d.error == "" && !d.locked && optional(st.cover_tried, d.name, nil) == nil { + if i < SHOWN_COVERS { + read_cover(d) + return true + } + if d.pages == nil || d.bytes == nil { + st.cover_tried[d.name] = true + st.busy = true + st.busy_at = time_now() + doc_facts(d) + return true + } } } false } fn read_cover(d){ st.cover_tried[d.name] = true - if d.cover != "" && d.pages != nil && fs.exists(d.cover) { + if optional(st.covers, d.name, nil) == nil && d.cover != "" && fs.exists(d.cover) { let src = try { binary_resource(fs.read_bytes(d.cover)) } catch { nil } if src != nil { st.covers[d.name] = src render_home() - start_timeout(0.02, || pump()) - return } } - let t = tab_named(d.name) - if t != nil && t.doc != nil { - cover_from(d, t.doc, false) - return - } st.busy = true st.busy_at = time_now() - engine("open", {path: d.path}, fn(a){ - if engine_gone(a) || outdated_open(a) { + engine("cover", {path: d.path dpi: COVER_DPI}, fn(a){ + if engine_gone(a) { st.busy = false render_home() return } + wrote(a) if !a.is_ok { - st.busy = false - if err_code(a.error) != "too_many_open" { doc_failed(d, a.error) } else { st.cover_tried[d.name] = nil } - render_home() - start_timeout(0.02, || pump()) + // A damaged or locked PDF says so on its card. No room + // (storage_full), a first page too large to draw small + // (too_large), or a shell without covers leaves the card without + // one, and its pages and size still come from the file (pdf.info + // writes nothing). + let e = a.error + if !outdated(e) && !storage_full(e) && err_code(e) != "too_large" { + doc_failed(d, e) + cover_done() + return + } + if d.pages == nil || d.bytes == nil { + doc_facts(d) + return + } + cover_done() return } - d.pages = optional(a.data, "pages", d.pages) - cover_from(d, a.data.doc, true) + let path = optional(a.data, "path", "") + let moved = path != d.cover + if moved || optional(st.covers, d.name, nil) == nil { + let src = try { binary_resource(fs.read_bytes(path)) } catch { nil } + if src != nil { st.covers[d.name] = src } + } + d.cover = path + if moved || d.pages == nil || d.bytes == nil { + doc_facts(d) + return + } + cover_done() }) } -fn cover_from(d, doc, close_after){ - st.busy = true - st.busy_at = time_now() - engine("info", {doc: doc}, fn(i){ +// A PDF's pages and size, from the file (the library keeps them). +fn doc_facts(d){ + engine("info", {path: d.path}, fn(i){ if i.is_ok { d.bytes = optional(i.data, "file_size", d.bytes) - if d.pages == nil { d.pages = optional(i.data, "pages", []).len() } + d.pages = optional(i.data, "pages", []).len() + } else if !outdated(i.error) { + doc_failed(d, i.error) } - engine("page", {doc: doc page: 1 dpi: COVER_DPI}, fn(a){ - wrote(a) - if a.is_ok { - let path = optional(a.data, "path", "") - let src = try { binary_resource(fs.read_bytes(path)) } catch { nil } - if src != nil { - st.covers[d.name] = src - d.cover = path - } - } - remember(d) - if close_after { - engine("close", {doc: doc discard: true}, fn(c){ cover_done() }) - } else { cover_done() } - }) + remember(d) + cover_done() }) } +// A saved PDF changed: its kept cover is out of date, so library.json names +// none, and Home asks pdf.cover for it again, whose new path makes it read +// the pages and size again too; the old picture shows until the new one comes +// (the service drops the old file then). +fn stale_cover(d){ + d.cover = "" + let tried = {} + for k v in st.cover_tried { if k != d.name { tried[k] = v } } + st.cover_tried = tried +} fn cover_done(){ st.busy = false render_home() @@ -761,11 +932,36 @@ fn check_files(){ if answer.is_ok { st.files_ok = optional(answer.data, "import_supported", false) && optional(answer.data, "storage_granted", false) st.max_import = optional(answer.data, "max_import_bytes", 0) + took_usage(answer.data) } render_home() }) }) } +// The status line's numbers, from files.status: what the app's storage +// holds, this service's renders and covers included, and what it may hold. +fn took_usage(data){ + let u = usage_from(data) + if u == nil { return } + st.used = u.used + st.quota = u.quota +} +// Ask files.status again a moment after a write: one question for a burst of +// writes (a page turn renders several pages). +fn storage_later(){ + if st.storage_due { return } + st.storage_due = true + start_timeout(0.8, || { + host.request("files.status", {}, fn(r){ + let answer = {is_ok: r.is_ok data: r.data} + start_timeout(0.01, || { + st.storage_due = false + if answer.is_ok { took_usage(answer.data) } + render_status() + }) + }) + }) +} fn import_limit(){ pick(st.max_import > 0, "Up to " + size_text(st.max_import), "") } // The host's refusal, said for a person; its own words go below it. fn import_refusal(error){ @@ -806,6 +1002,7 @@ fn imported(name, a){ return } if optional(a.data, "cancelled", false) { render_home() return } + storage_later() forget(name) let taken = [] for d in st.docs { taken.push(d.title) } @@ -827,7 +1024,7 @@ fn new_tab(d){ mode: "read" panel: "pages" panel_kept: "pages" zoom: 1.0 fit: "" zoom_auto: true anchor: 1 page: 1 renders: {} failed: {} thumbs: {} thumb_failed: {} grid: {} grid_failed: {} tile: 1.0 - find: nil finding: false + find: nil finding: false find_from: nil reading: false comments: nil comments_state: "" thread: nil tool: "highlight" color: "yellow" reply: "" status_menu: false head_menu: false pending: nil fields: nil fields_state: "" field: nil field_text: "" field_on: false show_fields: true place: nil place_text: "" selected: [] drag: nil inserting: false @@ -912,6 +1109,7 @@ fn show_tab(i){ fn go_home(){ st.screen = "home" scan_library() + storage_later() show() pump() } @@ -1026,16 +1224,22 @@ fn panel_w(t){ pick(t.panel == "pages", PANEL_W, LIST_W) } fn right_w(t){ pick(narrow(), 320, pick(t.mode == "comment", THREAD_W, RIGHT_W)) } // Below this width a right panel takes the left panel's place. fn narrow(){ st.width < 1180 } -fn canvas_w(){ +// A window too short for the Edit panel's measured gaps (the shell's default +// 603 points): the panel draws them tighter, so Apply stays in view. +fn short(){ st.height < 760 } +fn canvas_box(){ let t = cur_tab() - let w = st.width - RAIL_W - 1 - if t != nil { - if left_open(t) { w = w - panel_w(t) - 1 } - if right_open(t) { w = w - right_w(t) - 1 } + let reading = reading_on(t) + let left = 0 + let right = 0 + if t != nil && !reading { + if left_open(t) { left = panel_w(t) + 1 } + if right_open(t) { right = right_w(t) + 1 } } - max(240, w) + canvas_size(st.width, st.height, reading, left, right) } -fn canvas_h(){ max(240, st.height - TAB_H - MODE_H - STATUS_H - 2) } +fn canvas_w(){ canvas_box()[0] } +fn canvas_h(){ canvas_box()[1] } fn fit_width_zoom(t){ let s = page_pt(t, t.page) (canvas_w() - 48) / s[0] @@ -1078,6 +1282,32 @@ fn refit(t){ if t.fit == "page" { t.zoom = clamp(floor(fit_page_zoom(t) * 100) / 100, 0.25, 4.0) } } +// ---- Read mode ---------------------------------------------------------------- + +// Whether tab `t` shows its pages alone (its PDF open and ready). +fn reading_on(t){ t != nil && optional(t, "reading", false) && t.state == "ready" } +// From the floating bar's full-screen button: the same page, and the zoom +// the person chose, or the fit, worked out for the whole window (kept_zoom). +fn enter_reading(t){ + if t == nil || t.state != "ready" || t.mode == "pages" || t.mode == "combine" { return } + t.reading = true + reading_zoom(t) + show() + go_page(t, t.page) +} +// From the bar's Exit read mode or the corner control (a script gets no key +// events, so there is no Esc): the page and zoom it left Read mode with. +fn leave_reading(t){ + if t == nil || !optional(t, "reading", false) { return } + t.reading = false + reading_zoom(t) + show() + go_page(t, t.page) +} +fn reading_zoom(t){ + t.zoom = kept_zoom(t.zoom, t.zoom_auto, t.fit, fit_width_zoom(t), fit_page_zoom(t), start_zoom(t)) +} + // ---- the render pump: one engine render at a time --------------------------- fn pump(){ @@ -1152,7 +1382,8 @@ fn invalidate(t){ t.grid = {} t.grid_failed = {} t.lines = {} - t.find = nil + // Its matches are stale: the search ends, and the left side goes back. + drop_find(t) start_timeout(0.05, || pump()) } // Only page `p` changed (a comment, a filled field, an edited paragraph). @@ -1240,6 +1471,9 @@ fn find_text(text){ } t.finding = true t.find = {query: q total: 0 matches: [] cur: 0 error: "" by_page: {} pages: []} + // What the left side showed before the results took it: a new query + // while they show keeps it. + if t.panel != "search" { t.find_from = t.panel } t.panel = "search" let refit = auto_fit(t) show() @@ -1270,10 +1504,20 @@ fn find_text(text){ if t.find.matches.len() > 0 { go_match(t, 0) } }) } -fn end_find(t){ +// The search ends: its highlights go, and the left side shows what it did +// before (panel_after_find), now or when Comment or Edit gives it back. +// Draws nothing. +fn drop_find(t){ t.find = nil t.finding = false - if t.panel == "search" { t.panel = "pages" } + let back = panel_after_find(optional(t, "find_from", nil)) + if t.panel == "search" { t.panel = back } + if t.panel_kept == "search" { t.panel_kept = back } + t.find_from = nil +} +// Done, the results' cross, the field's cross or an empty query. +fn end_find(t){ + drop_find(t) let refit = auto_fit(t) show() if refit { go_page(t, t.page) } @@ -1373,6 +1617,10 @@ fn save(t, then){ let d = doc_named(t.name) if d != nil { d.bytes = optional(a.data, "bytes", d.bytes) + // Its pages as the open document has them (a page deleted and + // saved is gone from Home and Combine too). + if t.pages > 0 { d.pages = t.pages } + stale_cover(d) remember(d) } render_status() @@ -1389,12 +1637,15 @@ fn save(t, then){ fn page_tap(t, p, x, y){ t.page = p render_pill() + // Read mode reads: a tap marks, fills or edits nothing. + if reading_on(t) { return } if t.mode == "comment" { comment_tap(t, p, x, y, false) return } if t.mode == "fill" { fill_tap(t, p, x, y) return } if t.mode == "edit" { edit_tap(t, p, x, y) return } render_panel() } fn page_double_tap(t, p, x, y){ + if reading_on(t) { return } if t.mode == "comment" { comment_tap(t, p, x, y, true) } } fn inside(r, x, y){ x >= r[0] && x <= r[0] + r[2] && y >= r[1] && y <= r[1] + r[3] } @@ -1944,7 +2195,14 @@ fn edit_tap(t, p, x, y){ note("Click a paragraph of text to edit it.") return } - t.edit = {page: p n: hit.n box: hit.box text: hit.text draft: hit.text font: optional(hit, "font", "") size: optional(hit, "size", 0)} + // Its lines' boxes show how it is aligned (guess_align). + let boxes = [] + for n in optional(hit, "lines", []) { + for l in optional(lines, "lines", []) { if l.n == n { boxes.push(l.box) } } + } + let align = guess_align(boxes) + t.edit = {page: p n: hit.n box: hit.box text: hit.text draft: hit.text font: optional(hit, "font", "") size: optional(hit, "size", 0) + align: align align0: align color: nil colours: false} render_canvas() render_right() }) @@ -1952,13 +2210,13 @@ fn edit_tap(t, p, x, y){ fn apply_edit(t){ let e = t.edit if e == nil { return } - if e.draft == e.text { + if !edit_changes(e) { t.edit = nil render_canvas() render_right() return } - engine("edit_text", {doc: t.doc page: e.page paragraph: e.n text: e.draft}, fn(a){ + engine("edit_text", edit_args(t.doc, e), fn(a){ wrote(a) if !a.is_ok { note(action_failed("change the text", a.error)) @@ -1977,6 +2235,23 @@ fn cancel_edit(t){ render_canvas() render_right() } +fn set_align(t, a){ + if t == nil || t.edit == nil { return } + t.edit.align = a + render_right() +} +// `hex` nil: the paragraph keeps its own colour. +fn set_colour(t, hex){ + if t == nil || t.edit == nil { return } + t.edit.color = hex + t.edit.colours = false + render_right() +} +fn toggle_colours(t){ + if t == nil || t.edit == nil { return } + t.edit.colours = !t.edit.colours + render_right() +} fn font_text(e){ let size = pick(e.size > 0, "" + round(e.size * 10) / 10 + " pt", "") if e.font == "" { return size } @@ -2061,7 +2336,18 @@ fn render_canvas(){ ui.canvas.render() } fn render_pill(){ ui.pill.render() } fn render_toolrow(){ ui.toolrow.render() } fn render_grid(){ ui.grid.render() } -fn render_combine(){ ui.combine.render() } +fn render_combine(){ + let tight = combine_tight(cur_tab()) + ui.combine_fit.set_visible(!tight) + ui.combine_tall.set_visible(tight) + if tight { + ui.combine_tall_head.render() + ui.combine_list.render() + ui.combine_tall_foot.render() + } else { + ui.combine.render() + } +} fn render_status(){ ui.status.render() } fn render_dialog(){ ui.dialog_box.set_visible(st.confirm != nil) @@ -2087,20 +2373,27 @@ fn refresh_doc(){ fn show(){ let t = cur_tab() let doc = t != nil + let c = chrome_for(reading_on(t)) ui.home.set_visible(!doc) ui.doc.set_visible(doc) + ui.tabs_box.set_visible(c.tabs) + ui.status_box.set_visible(c.status) + ui.read_exit_box.set_visible(c.exit) if doc { let ready = t.state == "ready" - ui.panel_narrow.set_visible(ready && left_open(t) && t.panel == "pages") - ui.panel_wide.set_visible(ready && left_open(t) && t.panel != "pages") - ui.line_left.set_visible(ready && left_open(t)) + ui.modebar_box.set_visible(c.modebar) + ui.rail_box.set_visible(c.rail) + ui.toolrow_box.set_visible(c.toolrow) + ui.panel_narrow.set_visible(ready && c.panels && left_open(t) && t.panel == "pages") + ui.panel_wide.set_visible(ready && c.panels && left_open(t) && t.panel != "pages") + ui.line_left.set_visible(ready && c.panels && left_open(t)) ui.thumbs.set_visible(t.panel == "pages") ui.outline_box.set_visible(t.panel == "outline") ui.notes_box.set_visible(t.panel == "comments") ui.results_box.set_visible(t.panel == "search") - ui.right_thread_box.set_visible(ready && t.mode == "comment") - ui.right_side_box.set_visible(ready && (t.mode == "fill" || t.mode == "edit")) - ui.line_right.set_visible(ready && right_open(t)) + ui.right_thread_box.set_visible(ready && c.right && t.mode == "comment") + ui.right_side_box.set_visible(ready && c.right && (t.mode == "fill" || t.mode == "edit")) + ui.line_right.set_visible(ready && c.right && right_open(t)) ui.canvas.set_visible(ready && t.mode != "pages" && t.mode != "combine") ui.grid_box.set_visible(ready && t.mode == "pages") ui.combine_box.set_visible(ready && t.mode == "combine") @@ -2116,6 +2409,7 @@ fn show(){ if ready && t.mode == "combine" { render_combine() } if ready && t.mode != "pages" && t.mode != "combine" { render_canvas() } render_pill() + if c.exit { ui.read_exit.render() } } else { ui.home_pane.render() } @@ -2263,20 +2557,16 @@ fn search_field(t){ } } -// The rail: Pages, Outline, Comments, Search. +// The rail: Pages, Outline, Comments (RAIL). Search is the top bar's. fn rail_view(){ let t = cur_tab() View{width: Fill height: Fill flow: Down align: Align{x: 0.5} padding: Inset{top: 13} spacing: 8 - rail_item(t, "pages", "page", "Pages") - rail_item(t, "outline", "outline", "Outline") - rail_item(t, "comments", "comment", "Comments") - rail_item(t, "search", "search", "Search") + for r in RAIL { rail_item(t, r.id, r.icon, r.label) } } } fn rail_on(t, id){ if t == nil { return false } - if t.mode == "pages" { return id == "pages" } - left_open(t) && t.panel == id + rail_lit(id, t.mode, t.panel, left_open(t)) } fn rail_tap(id){ let t = cur_tab() @@ -2300,25 +2590,26 @@ fn rail_item(t, id, ic, label){ } } -// The left panel's head: its title and a cross that folds it away. -fn head_row(title, line){ +// The left panel's head: its title and a cross that folds it away, or, over +// search results (`ends_find`), ends the search as Done does. +fn head_row(title, line, ends_find){ View{width: Fill height: Fit flow: Down View{width: Fill height: 46 flow: Right align: Align{y: 0.5} padding: Inset{left: 15 right: 8} Label{padding: 0 width: Fill max_lines: 1 text_overflow: TextOverflow.Ellipsis text: title draw_text +: {color: pt_ink text_style: theme.font_bold{font_size: 13}}} IconBtn{width: 30 height: 30 icon_walk: Walk{width: 14 height: 14} draw_icon +: {svg: icon("close") color: pt_muted} - on_click: || { let t = cur_tab() if t != nil { set_panel(t, t.panel) } }} + on_click: || { let t = cur_tab() if t != nil { if ends_find { end_find(t) } else { set_panel(t, t.panel) } } }} } if line { Line{draw_bg.color: pt_line_soft} } } } -fn panel_head_view(){ head_row("Pages", false) } +fn panel_head_view(){ head_row("Pages", false, false) } fn list_head_view(){ let t = cur_tab() if t == nil { return View{width: Fill height: 1} } - if t.panel == "outline" { return head_row("Outline", true) } - if t.panel == "comments" { return head_row("Comments", true) } - if t.find == nil { return head_row("Search", true) } - head_row(find_summary(t), true) + if t.panel == "outline" { return head_row("Outline", true, false) } + if t.panel == "comments" { return head_row("Comments", true, false) } + if t.find == nil { return head_row("Search", true, true) } + head_row(find_summary(t), true, true) } // Pages panel: thumbnails, filled in one at a time. @@ -2633,6 +2924,7 @@ fn canvas_view(){ fn page_view(t, p){ let box = page_box(t, p) let k = t.zoom + let rd = reading_on(t) let src = page_src(t, p) let failed = optional(t.failed, "p" + p, nil) != nil && src == nil RectShadowView{width: box[0] height: box[1] flow: Overlay @@ -2645,12 +2937,13 @@ fn page_view(t, p){ } } if t.find != nil { for i in page_matches(t, p) { for r in t.find.matches[i].rects { hit_box(r, k, i == t.find.cur) } } } - if t.mode == "comment" { comment_marks(t, p, k) } - if t.mode == "fill" && t.show_fields && t.fields != nil { for f in t.fields { if f.page == p { field_box(t, f, k) } } } - GestureView{width: Fill height: Fill cursor: pick(t.mode == "read", MouseCursor.Default, MouseCursor.Hand) + // Read mode shows the pages alone: no tool's marks over them. + if t.mode == "comment" && !rd { comment_marks(t, p, k) } + if t.mode == "fill" && !rd && t.show_fields && t.fields != nil { for f in t.fields { if f.page == p { field_box(t, f, k) } } } + GestureView{width: Fill height: Fill cursor: pick(t.mode == "read" || rd, MouseCursor.Default, MouseCursor.Hand) on_tap: |x, y| page_tap(cur_tab(), p, x / k, y / k) on_double_tap: |x, y| page_double_tap(cur_tab(), p, x / k, y / k)} - if t.mode == "edit" && t.edit != nil && t.edit.page == p { edit_box(t, k) } + if t.mode == "edit" && !rd && t.edit != nil && t.edit.page == p { edit_box(t, k) } } } fn hit_box(r, k, on){ @@ -2735,9 +3028,26 @@ fn pill_view(){ SolidView{width: 1 height: 28 margin: Inset{left: 12 right: 12} draw_bg.color: pt_line} IconBtn{icon_walk: Walk{width: 21 height: 21} draw_icon +: {svg: icon("fit-width") color: pick(t.fit == "width", pt_accent, pt_icon)} on_click: || { let x = cur_tab() set_zoom(x, fit_width_zoom(x), "width") }} IconBtn{margin: Inset{left: 6} icon_walk: Walk{width: 21 height: 21} draw_icon +: {svg: icon("fit-page") color: pick(t.fit == "page", pt_accent, pt_icon)} on_click: || { let x = cur_tab() set_zoom(x, fit_page_zoom(x), "page") }} + SolidView{width: 1 height: 28 margin: Inset{left: 12 right: 12} draw_bg.color: pt_line} + // Design 02's bar ends with full screen: Read mode, the pages + // alone; in it, the way back, always on the bar. + if !reading_on(t) { + IconBtn{icon_walk: Walk{width: 20 height: 20} draw_icon +: {svg: icon("fullscreen") color: pt_icon} on_click: || enter_reading(cur_tab())} + } + if reading_on(t) { + Flat{height: 36 padding: Inset{left: 10 right: 12} spacing: 8 text: "Exit read mode" icon_walk: Walk{width: 18 height: 18} draw_icon +: {svg: icon("fullscreen-exit") color: pt_icon} + draw_text +: {color: pt_ink2 color_hover: pt_ink color_down: pt_ink text_style: theme.font_regular{font_size: 12}} + on_click: || leave_reading(cur_tab())} + } } } } +// Read mode's corner control, top right: quiet, and always there. +fn read_exit_view(){ + RoundedView{width: Fit height: Fit padding: 3 show_bg: true draw_bg +: {color: pt_corner border_size: 1.0 border_color: pt_line border_radius: 18.0} + IconBtn{width: 30 height: 30 icon_walk: Walk{width: 15 height: 15} draw_icon +: {svg: icon("fullscreen-exit") color: pt_muted} on_click: || leave_reading(cur_tab())} + } +} // Pages mode: every page as a large thumbnail; tap to choose, drag to move. fn grid_view(){ @@ -2798,35 +3108,76 @@ fn drop_marker(h){ } } -// Combine: PDFs in order, each with its pages, into one new PDF. +// Combine: PDFs in order, each with its pages, into one new PDF (design +// 06). When its list fits the window, the card is as tall as it is, in a pane +// that scrolls; when it does not (a short window, many PDFs), the card fills +// the pane, its title and footer (the total, Name and the button) stay in +// view, and the list scrolls inside it, in a scroll view of its own that +// keeps its place as the list is drawn again (render_combine). +fn combine_tight(t){ + if t == nil || t.combine == nil { return false } + let c = t.combine + let rows = 0 + if c.adding { + rows = 1 + for d in st.docs { if !combine_has(t, d.name) && d.error == "" && !d.locked { rows = rows + 1 } } + } + !combine_fits(combine_list_h(c.items.len(), rows), st.height, c.error != "") +} fn combine_view(){ let t = cur_tab() if t == nil || t.combine == nil { return View{width: Fill height: 1} } - let c = t.combine - let total = combine_total(t) RoundedShadowView{width: Fill max_width: 717 height: Fit flow: Down padding: Inset{left: 24 right: 24 top: 34 bottom: 24} draw_bg +: {color: pt_card border_size: 1.0 border_color: pt_line border_radius: 7.0 shadow_color: pt_shadow shadow_radius: 8.0 shadow_offset: vec2(0.0, 1.0)} - View{width: Fit height: Fit padding: Inset{left: 16 bottom: 22} Label{padding: 0 text: "Combine files" draw_text +: {color: pt_ink text_style: theme.font_bold{font_size: 16}}}} - RoundedView{width: Fill height: Fit flow: Down show_bg: true draw_bg +: {color: pt_card border_size: 1.0 border_color: pt_line border_radius: 3.0} - for i it in c.items { - combine_row(t, i, it) - Line{draw_bg.color: pt_line_soft} - } - GestureView{width: Fill height: 60 padding: Inset{left: 8 right: 8 top: 9 bottom: 9} cursor: MouseCursor.Hand on_tap: |x, y| { let x = cur_tab() x.combine.adding = !x.combine.adding render_combine() } - dashed_box() - } - if c.adding { add_list(t) } + combine_head(false) + combine_items(t) + combine_foot(t, false) + } +} +// The tall card's parts (the static frame around them is in the layout). +fn tall_head_view(){ combine_head(true) } +fn tall_list_view(){ + let t = cur_tab() + if t == nil || t.combine == nil { return View{width: Fill height: 1} } + combine_items(t) +} +fn tall_foot_view(){ + let t = cur_tab() + if t == nil || t.combine == nil { return View{width: Fill height: 1} } + combine_foot(t, true) +} +fn combine_head(tight){ + View{width: Fit height: Fit padding: Inset{left: 16 bottom: pick(tight, 14, 22)} Label{padding: 0 text: "Combine files" draw_text +: {color: pt_ink text_style: theme.font_bold{font_size: 16}}}} +} +fn combine_items(t){ + let c = t.combine + RoundedView{width: Fill height: Fit flow: Down show_bg: true draw_bg +: {color: pt_card border_size: 1.0 border_color: pt_line border_radius: 3.0} + for i it in c.items { + combine_row(t, i, it) + Line{draw_bg.color: pt_line_soft} } - Line{margin: Inset{top: 18 bottom: 20}} + GestureView{width: Fill height: 60 padding: Inset{left: 8 right: 8 top: 9 bottom: 9} cursor: MouseCursor.Hand on_tap: |x, y| { let x = cur_tab() x.combine.adding = !x.combine.adding render_combine() } + dashed_box() + } + if c.adding { add_list(t) } + } +} +// What the card ends with: the total, the new PDF's name, a refusal, Combine. +// A tall card draws its gaps tighter, to leave the list room. +fn combine_foot(t, tight){ + let c = t.combine + let total = combine_total(t) + View{width: Fill height: Fit flow: Down + Line{margin: Inset{top: pick(tight, 12, 18) bottom: pick(tight, 12, 20)}} Label{padding: 0 text: pick(total == nil, "Check the pages of each PDF", "One PDF of " + plural(total, "page", "pages")) draw_text +: {color: pt_ink2 text_style: theme.font_regular{font_size: 13}}} - View{width: Fill height: Fit flow: Right align: Align{y: 0.5} margin: Inset{top: 22} spacing: 18 + View{width: Fill height: Fit flow: Right align: Align{y: 0.5} margin: Inset{top: pick(tight, 12, 22)} spacing: 18 Label{padding: 0 text: "Name" draw_text +: {color: pt_ink2 text_style: theme.font_regular{font_size: 12}}} Field{width: 310 height: 40 text: c.name empty_text: "Name of the new PDF" on_change: |text| { let x = cur_tab() x.combine.name = text }} } if c.error != "" { - View{width: Fill height: Fit padding: Inset{top: 14} Label{padding: 0 width: Fill flow: Flow.Right{wrap: true} text: c.error draw_text +: {color: pt_red text_style: theme.font_regular{font_size: 12}}}} + View{width: Fill height: Fit padding: Inset{top: pick(tight, 10, 14)} Label{padding: 0 width: Fill flow: Flow.Right{wrap: true} text: c.error draw_text +: {color: pt_red text_style: theme.font_regular{font_size: 12}}}} } - View{width: Fill height: Fit flow: Right margin: Inset{top: 14} + View{width: Fill height: Fit flow: Right margin: Inset{top: pick(tight, 10, 14)} Gap{} Primary{width: 140 height: 46 spacing: 10 text: pick(c.busy, "Combining…", "Combine") icon_walk: Walk{width: 18 height: 18} draw_icon +: {svg: icon("combine")} draw_text +: {text_style: theme.font_regular{font_size: 13}} @@ -3165,12 +3516,16 @@ fn edit_panel(t){ Label{padding: 0 text: "Paragraph " + t.edit.n draw_text +: {color: pt_ink2 text_style: theme.font_regular{font_size: 12.5}}} } Line{draw_bg.color: pt_line_soft} - View{width: Fill height: Fit flow: Down padding: Inset{left: 16 right: 16 top: 18 bottom: 20} spacing: 10 + View{width: Fill height: Fit flow: Down padding: Inset{left: 16 right: 16 top: pick(short(), 12, 18) bottom: pick(short(), 12, 20)} spacing: pick(short(), 8, 10) Label{padding: 0 text: "Font" draw_text +: {color: pt_ink2 text_style: theme.font_regular{font_size: 12}}} RoundedView{width: Fill height: 40 flow: Right align: Align{y: 0.5} padding: Inset{left: 12 right: 12} show_bg: true draw_bg +: {color: pt_field border_size: 1.0 border_color: pt_field_line border_radius: 4.0} Label{padding: 0 width: Fill max_lines: 1 text_overflow: TextOverflow.Ellipsis text: font_text(t.edit) draw_text +: {color: pt_ink2 text_style: theme.font_regular{font_size: 12}}} } - View{width: Fill height: Fit flow: Right margin: Inset{top: 22} spacing: 14 + View{width: Fill height: Fit padding: Inset{top: pick(short(), 4, 14)} Label{padding: 0 text: "Alignment" draw_text +: {color: pt_ink2 text_style: theme.font_regular{font_size: 12}}}} + align_segments(t.edit) + View{width: Fill height: Fit padding: Inset{top: pick(short(), 4, 14)} Label{padding: 0 text: "Colour" draw_text +: {color: pt_ink2 text_style: theme.font_regular{font_size: 12}}}} + colour_box(t.edit) + View{width: Fill height: Fit flow: Right margin: Inset{top: pick(short(), 12, 22)} spacing: 14 Primary{width: Fill height: 37 text: "Apply" on_click: || apply_edit(cur_tab())} Outline{width: Fill height: 37 text: "Cancel" on_click: || cancel_edit(cur_tab())} } @@ -3180,6 +3535,67 @@ fn edit_panel(t){ } } +// Alignment: four segments (left, centre, right, justify), the paragraph's +// own (guess_align) chosen until another is tapped. +fn align_segments(e){ + RoundedView{width: Fill height: 40 flow: Right padding: 2 spacing: 2 show_bg: true draw_bg +: {color: pt_field border_size: 1.0 border_color: pt_field_line border_radius: 4.0} + for a in ALIGNS { + GestureView{width: Fill height: Fill cursor: MouseCursor.Hand on_tap: |x, y| set_align(cur_tab(), a) + RoundedView{width: Fill height: Fill align: Align{x: 0.5 y: 0.5} show_bg: true + draw_bg +: {color: pick(e.align == a, pt_select, pt_field) border_size: 1.0 border_color: pick(e.align == a, pt_accent, pt_field) border_radius: 3.0} + Ico{width: 20 height: 20 draw_svg +: {svg: icon("align-" + a) color: pick(e.align == a, pt_accent, pt_icon)}} + } + } + } + } +} +// A text colour as the Edit panel shows it (TEXT_COLOURS). +fn text_swatch(hex){ + if hex == "#4b4f54" { return #x4b4f54 } + if hex == "#1a5fb4" { return #x1a5fb4 } + if hex == "#c01c28" { return #xc01c28 } + if hex == "#26a269" { return #x26a269 } + if hex == "#e66100" { return #xe66100 } + #x000000 +} +// A colour's square; an empty one for the paragraph's own colour, which the +// engine doesn't report. +fn swatch(hex){ + if hex == nil { + return RoundedView{width: 22 height: 22 show_bg: true draw_bg +: {color: pt_field border_size: 1.0 border_color: pt_thumb_line border_radius: 4.0}} + } + RoundedView{width: 22 height: 22 show_bg: true draw_bg +: {color: text_swatch(hex) border_size: 1.0 border_color: pt_thumb_line border_radius: 4.0}} +} +// Colour: the chosen colour in a box that opens into the colours, in its own +// row (the runtime gives a script no pop-up menu, and the panel is short in +// a small window: Apply stays in view). +fn colour_box(e){ + if e.colours { return colour_list(e) } + GestureView{width: Fill height: 40 cursor: MouseCursor.Hand on_tap: |x, y| toggle_colours(cur_tab()) + RoundedView{width: Fill height: Fill flow: Right align: Align{y: 0.5} padding: Inset{left: 9 right: 12} spacing: 12 show_bg: true draw_bg +: {color: pt_field border_size: 1.0 border_color: pick(e.colours, pt_accent, pt_field_line) border_radius: 4.0} + swatch(e.color) + Label{padding: 0 width: Fill text: colour_name(e.color) draw_text +: {color: pt_ink2 text_style: theme.font_regular{font_size: 12}}} + Ico{width: 16 height: 16 draw_svg +: {svg: icon(pick(e.colours, "chevron-up", "chevron-down")) color: pt_icon}} + } + } +} +// The colours the box opens into, the paragraph's own first: tap one to +// choose it and close them. +fn colour_chip(e, hex){ + GestureView{width: 30 height: 30 align: Align{x: 0.5 y: 0.5} cursor: MouseCursor.Hand on_tap: |x, y| set_colour(cur_tab(), hex) + RoundedView{width: 30 height: 30 align: Align{x: 0.5 y: 0.5} show_bg: true + draw_bg +: {color: pick(e.color == hex, pt_select, pt_field) border_size: 1.0 border_color: pick(e.color == hex, pt_accent, pt_field) border_radius: 4.0} + swatch(hex) + } + } +} +fn colour_list(e){ + RoundedView{width: Fill height: 40 flow: Right align: Align{y: 0.5} padding: Inset{left: 4 right: 4} spacing: 4 show_bg: true draw_bg +: {color: pt_field border_size: 1.0 border_color: pt_accent border_radius: 4.0} + colour_chip(e, nil) + for c in TEXT_COLOURS { colour_chip(e, c.hex) } + } +} + // What a tab shows when its PDF isn't open: opening, damaged, protected, // no engine, too many open. fn notice_view(){ @@ -3310,15 +3726,26 @@ fn doc_card(d, days){ } } +// What the status line says of the storage: files.status's numbers, or, +// from a host that doesn't give them, the library's PDFs against the +// system ceiling; and how much of the bar that fills. +fn storage_text(){ + if st.used >= 0 && st.quota > 0 { return used_text(st.used, st.quota) } + used_text(library_bytes(), QUOTA) +} +fn storage_share(){ + if st.used >= 0 && st.quota > 0 { return min(1, st.used / st.quota) } + min(1, library_bytes() / QUOTA) +} // The status line: whether the open PDF is saved, and the storage used. fn status_view(){ let t = cur_tab() - let used = used_text(library_bytes()) + let used = storage_text() if t == nil { return View{width: Fill height: Fill flow: Right align: Align{y: 0.5} padding: Inset{left: 20 right: 29} spacing: 20 Label{padding: 0 text: used draw_text +: {color: pt_muted text_style: theme.font_regular{font_size: 11}}} RoundedView{width: Fill max_width: 1110 height: 6 flow: Right show_bg: true draw_bg +: {color: pt_line_soft border_radius: 3.0} - RoundedView{width: max(6, floor(min(1, library_bytes() / QUOTA) * min(1110, st.width - 230))) height: Fill show_bg: true draw_bg +: {color: pick(st.space_full, pt_red, pt_accent) border_radius: 3.0}} + RoundedView{width: max(6, floor(storage_share() * min(1110, st.width - 230))) height: Fill show_bg: true draw_bg +: {color: pick(st.space_full, pt_red, pt_accent) border_radius: 3.0}} } } } @@ -3362,16 +3789,24 @@ fn dialog_view(){ SolidView{width: Fill height: Fill flow: Overlay draw_bg.color: pt_desk View{width: Fill height: Fill flow: Down - tabs := SolidView{width: Fill height: TAB_H draw_bg.color: pt_tabs on_render: || { tabs_view() }} + // Read mode hides these regions through plain wrappers (a view + // whose on_render starts hidden stays hidden). + tabs_box := View{width: Fill height: Fit + tabs := SolidView{width: Fill height: TAB_H draw_bg.color: pt_tabs on_render: || { tabs_view() }} + } home := SolidView{width: Fill height: Fill flow: Down draw_bg.color: pt_home home_pane := ScrollYView{width: Fill height: Fill flow: Down on_render: || { home_view() }} } doc := View{visible: false width: Fill height: Fill flow: Down - modebar := SolidView{width: Fill height: MODE_H draw_bg.color: pt_bar on_render: || { modebar_view() }} - Line{} + modebar_box := View{width: Fill height: Fit flow: Down + modebar := SolidView{width: Fill height: MODE_H draw_bg.color: pt_bar on_render: || { modebar_view() }} + Line{} + } View{width: Fill height: Fill flow: Right - rail := SolidView{width: RAIL_W height: Fill draw_bg.color: pt_rail on_render: || { rail_view() }} - VLine{} + rail_box := View{width: Fit height: Fill flow: Right + rail := SolidView{width: RAIL_W height: Fill draw_bg.color: pt_rail on_render: || { rail_view() }} + VLine{} + } panel_narrow := SolidView{visible: false width: PANEL_W height: Fill flow: Down draw_bg.color: pt_panel panel_head := View{width: Fill height: Fit on_render: || { panel_head_view() }} thumbs := ScrollYView{width: Fill height: Fill flow: Down on_render: || { thumbs_view() }} @@ -3392,14 +3827,27 @@ SolidView{width: Fill height: Fill flow: Overlay draw_bg.color: pt_desk } line_left := VLine{visible: false} View{width: Fill height: Fill flow: Down - toolrow := View{width: Fill height: Fit flow: Down on_render: || { toolrow_view() }} + toolrow_box := View{width: Fill height: Fit + toolrow := View{width: Fill height: Fit flow: Down on_render: || { toolrow_view() }} + } View{width: Fill height: Fill flow: Overlay canvas := ScrollXYView{width: Fill height: Fill flow: Down align: Align{x: 0.5} padding: Inset{top: PAGE_TOP bottom: 92 left: 24 right: 24} on_render: || { canvas_view() }} grid_box := View{visible: false width: Fill height: Fill grid := ScrollYView{width: Fill height: Fill flow: Down align: Align{x: 0.5} padding: Inset{left: 20 right: 20 top: 14 bottom: 92} on_render: || { grid_view() }} } - combine_box := View{visible: false width: Fill height: Fill - combine := ScrollYView{width: Fill height: Fill flow: Down align: Align{x: 0.5} padding: Inset{top: 42 bottom: 40 left: 24 right: 24} on_render: || { combine_view() }} + combine_box := View{visible: false width: Fill height: Fill flow: Down + combine_fit := View{width: Fill height: Fill + combine := ScrollYView{width: Fill height: Fill flow: Down align: Align{x: 0.5} padding: Inset{top: 42 bottom: 40 left: 24 right: 24} on_render: || { combine_view() }} + } + // A short window: the card fills the pane and its list scrolls inside it. + combine_tall := View{visible: false width: Fill height: Fill flow: Down align: Align{x: 0.5} padding: Inset{top: 16 bottom: 16 left: 24 right: 24} + RoundedShadowView{width: Fill max_width: 717 height: Fill flow: Down padding: Inset{left: 24 right: 24 top: 20 bottom: 18} + draw_bg +: {color: pt_card border_size: 1.0 border_color: pt_line border_radius: 7.0 shadow_color: pt_shadow shadow_radius: 8.0 shadow_offset: vec2(0.0, 1.0)} + combine_tall_head := View{width: Fill height: Fit on_render: || { tall_head_view() }} + combine_list := ScrollYView{width: Fill height: Fill flow: Down on_render: || { tall_list_view() }} + combine_tall_foot := View{width: Fill height: Fit flow: Down on_render: || { tall_foot_view() }} + } + } } notice_box := View{visible: false width: Fill height: Fill notice := View{width: Fill height: Fill flow: Down align: Align{x: 0.5 y: 0.4} padding: 24 on_render: || { notice_view() }} @@ -3417,8 +3865,13 @@ SolidView{width: Fill height: Fill flow: Overlay draw_bg.color: pt_desk } } } - Line{} - status := SolidView{width: Fill height: STATUS_H draw_bg.color: pt_status on_render: || { status_view() }} + status_box := View{width: Fill height: Fit flow: Down + Line{} + status := SolidView{width: Fill height: STATUS_H draw_bg.color: pt_status on_render: || { status_view() }} + } + } + read_exit_box := View{visible: false width: Fill height: Fill flow: Down align: Align{x: 1.0 y: 0.0} padding: 12 + read_exit := View{width: Fit height: Fit on_render: || { read_exit_view() }} } banner := View{visible: false width: Fill height: Fill flow: Down align: Align{x: 0.5 y: 1.0} padding: Inset{left: 16 right: 16 bottom: 84} RoundedView{width: Fill max_width: 560 height: Fit flow: Right align: Align{y: 0.5} padding: Inset{left: 16 right: 6 top: 6 bottom: 6} diff --git a/apps/pdftools/design/SERVICE.md b/apps/pdftools/design/SERVICE.md index d460b33c..a6f9899a 100644 --- a/apps/pdftools/design/SERVICE.md +++ b/apps/pdftools/design/SERVICE.md @@ -36,6 +36,10 @@ goes to both. Derived from `BRIEF.md` (Actions and the engine). the `comments` rects, the `fields` rect and the `rects` input of a comment add. Find's match rects can go straight into a highlight. - **Handles:** `doc` is a string (lowercase hex). +- **Storage use** is the shell's, not this service's: PDF Tools' status line + ("14.6 of 64 MB used") reads `used_bytes` and `quota_bytes` from the shell's + `files.status`, which count everything in its storage, this service's + render cache and covers included. ## Documents @@ -56,15 +60,26 @@ Caps: the file is at most 128 MiB (`MAX_PDF_BYTES`). | `pdf.find` | `{doc, query, limit?}` | `{total, matches: [{page, rects: [[x, y, w, h], …], snippet}]}`, snippet ≤ 120 characters with the match marked `[[…]]` | | `pdf.lines` | `{doc, page}` | `{lines: [{n, text, box, font, size}], paragraphs: [{n, text, box, lines, font, size}]}` | | `pdf.text` | `{path, pages?}` (as today) or `{doc, pages?}` | as today | +| `pdf.cover` | `{path, dpi?}` | `{path, width, height, dpi}`: page 1 of the PDF at `path` (in storage) rendered as a PNG written to `.cache/covers/@.png`, kept across `pdf.close` and the app closing | Caps: `dpi` 24 to 300 (default 96), and at most 16 megapixels per render. A fractional `dpi` is rounded; one out of range is `invalid:`, not clamped. A single render whose PNG is over 16 MiB is `too_large:`. `limit` at most 500 -(default 200); `total` saturates at 10,000. The render cache is at most 16 MiB -and 64 files per app (app storage allows 256 entries in all, and imports and -library saves need room): the oldest renders go first, and it is cleared -before a write would fail with `storage_full:`. A render of an edited -document reflects its unsaved edits. +(default 200); `total` saturates at 10,000. The render cache, page renders +and covers together, is at most 16 MiB and 64 files per app (app storage +allows 256 entries in all, and imports and library saves need room), at most +32 of them covers: page renders go before covers, each oldest first, and the +whole cache is cleared before a write would fail with `storage_full:`. A +render of an edited document reflects its unsaved edits. + +`pdf.cover`: `dpi` 24 to 150 (default 48), at most 16 megapixels. Its `key` +is `--`, lowercase hex and digits: a hash of the file's +storage-relative name, its size in bytes and its modification time, so a +changed file gets a new cover and the file's older covers go (another file's +never). A kept cover answers without opening the file; a new one opens it +without an open document (no handle, not counted toward the 8). Its errors +are `pdf.info`'s (`not_found:`, `damaged:`, `protected:`, `too_large:`, +`invalid:`) and `storage_full:`. ## Comments @@ -77,8 +92,11 @@ document reflects its unsaved edits. | `pdf.comment` | `{doc, op: "reply", id, text, author?}` | `{id}` (the reply's) | | `pdf.comment` | `{doc, op: "status", id, status}` | `{id}`; `status` is `accepted`, `rejected`, `cancelled`, `completed` or `none` | -A comment's `date` is local time without a zone or seconds -(`2026-10-10T22:21`), and its `rects` is one bounding box. An unnamed comment's +A comment's and a reply's `date` is this device's local time without a zone +or seconds (`2026-10-10T22:21`): the service reads each date as the file +writes it and converts it from its zone (`Z`, as the engine stamps its own +marks, or `±hh'mm'`); a date written without a zone is taken as written. A +comment's `rects` is one bounding box. An unnamed comment's id is `@page-index`. Fill & Sign marks appear in the list. Without `author` the engine writes "PdfCraft": always pass the person's name (PDF Tools asks once, "Comment as", and keeps it in its storage). @@ -111,7 +129,12 @@ Caps: at most 512 pages named in one call. | Method | Arguments | Answer | | --- | --- | --- | -| `pdf.edit_text` | `{doc, page, paragraph?, line?, text}` | `{edited: true}`; exactly one of `paragraph` or `line`, numbers from `pdf.lines` | +| `pdf.edit_text` | `{doc, page, paragraph?, line?, text, align?, color?}` | `{edited: true}`; exactly one of `paragraph` or `line`, numbers from `pdf.lines` | + +`align` (`left`, `center`, `right` or `justify`) and `color` (`#rrggbb`) format +a paragraph and are refused with `line`; the paragraph keeps its font, size +and place. Without `align` its lines are set flush left, and without `color` +it keeps its own; `pdf.lines` reports neither. ## History and saving diff --git a/apps/pdftools/dev-fixture/engine.splash b/apps/pdftools/dev-fixture/engine.splash index fc247735..2223a31d 100644 --- a/apps/pdftools/dev-fixture/engine.splash +++ b/apps/pdftools/dev-fixture/engine.splash @@ -117,6 +117,21 @@ fn fx_answer(x, method, args){ } return fx_new_file(x, args.out, order) } + if method == "cover" { + // SERVICE.md "Reading": page 1 of a PDF in storage, at 24 to 150 dpi. + let name = fx_name(args.path) + if has(optional(x.f, "damaged", []), name) { return fx_err("damaged: the file's cross-reference table is broken (dev fixture)") } + if has(optional(x.f, "protected", []), name) { return fx_err("protected: this PDF needs a password to open") } + let d = optional(x.f.docs, name, nil) + if d == nil { return fx_err("not_found: " + args.path + " is not in this app's storage") } + let dpi = optional(args, "dpi", 48) + if dpi < 24 || dpi > 150 { return fx_err("invalid: pdf.cover: `dpi` is 24 to 150") } + // A merged file's first page is drawn by the PDF it came from. + let first = {name: name p: 1} + let map = optional(d, "map", nil) + if map != nil { first = map[0] } + return fx_ok({path: "dev/pages/" + x.f.docs[first.name].id + "/" + first.p + ".png" width: 0 height: 0 dpi: dpi}) + } if method == "info" && optional(args, "doc", nil) == nil { let d = optional(x.f.docs, fx_name(args.path), nil) if d == nil { return fx_err("not_found: " + args.path) } @@ -218,6 +233,12 @@ fn fx_answer(x, method, args){ } if method == "pages" { return fx_pages(x, s, args) } if method == "edit_text" { + // SERVICE.md "Edit": align and color format a paragraph only. + let align = optional(args, "align", nil) + let color = optional(args, "color", nil) + if (align != nil || color != nil) && optional(args, "paragraph", nil) == nil { return fx_err("invalid: pdf.edit_text: `align` and `color` format a paragraph: give `paragraph`, not `line`") } + if align != nil && !has(["left", "center", "right", "justify"], align) { return fx_err("invalid: pdf.edit_text: `align` is left, center, right, justify, not " + align) } + if color != nil && !regex("^#[0-9a-fA-F]{6}$").test("" + color) { return fx_err("invalid: pdf.edit_text: `color` is #rrggbb, not " + color) } fx_change(s) return fx_ok({edited: true}) } diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/README.md b/apps/pdftools/tests/evidence/v2-followups-20261010/README.md new file mode 100644 index 00000000..ff0a9719 --- /dev/null +++ b/apps/pdftools/tests/evidence/v2-followups-20261010/README.md @@ -0,0 +1,146 @@ +# PDF Tools v2 follow-ups — 2026-10-11 + +English | [简体中文](README.zh-CN.md) + +[ui.py](../../ui.py) ran the follow-ups end to end on this branch (macOS, +Apple silicon), on main 07b63dac, which has #478. Afterwards the branch was +rebased onto main bcd52cf4. That brought in #484 alone: WASI sockets, with +App Hub's pin moved from d86101d7 to c317f787. The runs were not repeated on +it. [receipt.json](receipt.json) holds the binaries', bundle's and sources' +digests, the commands, what each run checked, the numbers it saw and what was +not verified. The folder is named for the first round, on 10 Oct; this +round's frames replaced that round's. + +**The hidden desktop shell, with the real `pdf` engine** (`cargo build +--locked -p octosense --no-default-features --features app-hub,craft-engines`, +debug): +- Each run had a fresh `OCTOSENSE_HOME` with the sample PDFs that + octosense-pdf-service's `pdftools_fixture` example writes. +- The shell started from a Terminal.app tab with `MAKEPAD_HIDE_WINDOWS=1`, + `MAKEPAD_REMOTE=127.0.0.1:8915` and `MAKEPAD_WM_TEST_APP=pdftools`, under + the machine's shell-run lock, one instance at a time, and ended with + `/quit`. +- PDF Tools opened at its own window size (#478): an app area of 1292 x 662 + points, the wide layout. Every engine call was real. +- Each frame is the app's area cut from an original `/g` grab, one pixel per + point. +- The runs were just after midnight on 11 Oct in California, 7 hours behind + UTC. +- They ran with `--budget-ms 1000`, not the runtime's 64 ms. See + [The 64 ms budget](#the-64-ms-budget) below. + +The frames: +- [light/](light): + - **01-home:** each PDF's cover from `pdf.cover`. The status line reads + "187 KB of 64 MB used" from `files.status`; the storage held 191,793 + bytes. The PDFs alone are 38,356 bytes, which is all the old line + counted. + - **02c-read-mode, 02d-read-mode-zoomed, 02e-read-mode-left:** Read mode, + from the floating bar's last button, on page 2 of 4. + - The tabs, mode bar, rail, panels and status line are gone. + - The bar keeps the page arrows, "2 / 4", zoom, fit width, fit page and + "Exit read mode". An exit control sits in the top right corner. + - Then page 3 at 125%. Exit read mode leaves on page 3 at 125%. + - **03-find, 03b-find-done:** with the Comments panel open, "revenue" in + the top bar's search. "9 matches on 4 pages" fills the left panel with + no rail item lit; the rail has no Search of its own. Done gives the + Comments panel back. + - **04-comment, 04b-replied:** a highlight and its reply, dated "Today + 00:34" at 07:34 UTC. The old reading took the engine's UTC time for + local time and showed 07:34. + - **06-combine, 06a-combine-end, 06b-combined:** two PDFs in Combine. The + file list scrolls inside the card. "One PDF of 5 pages", Name and the + Combine button stay in view with no scroll: the button sits at 613 to + 659 of the app's 662 points. Before, it was 85 points below the fold. + Then the combined PDF. + - **08-edit, 08a-colours, 08b-edited:** clause 1 of the lease with + Alignment centred and Colour Red. The Colour box opens into a row of + seven chips: the paragraph's own colour and six others. After Apply, the + engine draws the paragraph centred and red. + - **09-saved.** +- [dark/](dark): the same after the shell's own switch to its dark style, on + what the light pass left. So the report's tab is still Edited with the + light pass's highlight, and Combine names its PDF "Quarterly report + combined 2". + - **02c-read-mode, 02e-read-mode-left:** Read mode, left this time by the + corner control, on page 3 at 125%. + - **03-find:** before the search, the rail's Pages folded the left side. + The results' own cross then ended the search and folded it again + (checked; no frame). + - **08-edit, 08b-edited:** the paragraph set flush right, keeping its own + colour. +- [restart/](restart): the same home after a restart. + - **r01-home, r02-imported:** the covers kept from the shell run were not + drawn again: the same files, with the same times. One new cover was + drawn, for `Imported PDF.pdf`, placed in the library between the runs. + - **r03-place-kept:** the report reopens on page 2, where the shell run + left it. + - **r04-removed:** removing "Quarterly report combined.pdf" deleted its + kept cover too. The card beside the message is the dark pass's + "Quarterly report combined 2.pdf". +- [full/](full): the storage filled to 8 KB short of its 64 MiB. + - The status line reads "63.9 of 64 MB used", with the bar full and red. + - There is no room for covers, but each card still shows its pages and + size. + - Removing a PDF asks once more, then removes it. +- [empty/](empty): no PDFs, light and dark. + +**App Hub's `card-host`**, which serves no host services, at the designs' +1536 x 1024 ([fixture/](fixture)). It ran ui.py's `fixture` run: a scratch +copy of the bundle with the stand-in engine and the designs' sample +documents, light then dark. It used `--budget-ms 1000` because the stand-in +engine answers in script. + +The card-host on this machine (App Hub 8347a489) predates the manifest's +`window` hint and refuses unknown manifest keys. So the scratch copy's +manifest dropped `window` and `schema_minor`; `main.splash` is the branch's +own. + +The sheets, design on the left and app on the right, are halved and reduced +to 256 colours: +- **02-reading:** the floating bar ends with Read mode's button. +- **03-find, d03-find:** the find screen from the top bar alone, light and + dark. Design 03 still draws a Search item in the rail. The app has + dropped it, so no rail item is lit. +- **06-combine:** the card fits as design 06 draws it at this height. +- **08-edit, d08-edit:** the Edit panel with Font, Alignment and Colour, as + design 08 draws it. + +Every frame was inspected. + +## The 64 ms budget + +After the go, the shell run first ran at the runtime's 64 ms script budget. + +- The first attempt stopped at a bug in ui.py: the new rail check also + counted the tab title and "Saved". The app was right, and ui.py was + fixed. +- The next two attempts passed every functional step of the shell journey, + light and dark. That covers Read mode, find from the top bar, a highlight + and its reply, Pages, Combine, Fill & Sign, Edit with Alignment and + Colour, save and the damaged file: 41 frames, through d10-damaged. +- Each then failed only ui.py's log check, on script budget overruns. So + `restart`, `full` and `empty` did not run: + - **The second attempt** logged two "script time budget exceeded" around + a 555 ms stall of the UI thread in `pdf.save`: a file rename, then the + removal of its staging folder. The third attempt overwrote its log. + [run-64ms/attempt-2-excerpt.txt](run-64ms/attempt-2-excerpt.txt) holds + the lines read from it before then. + - **The third attempt** logged one, after a 262 ms stall in the render + cache's file rename (`pdf.page`, `cache::store`). Its logs are + [run-64ms/shell.log](run-64ms/shell.log) and + [run-64ms/ui.log](run-64ms/ui.log), with machine-local paths replaced by + placeholders. +- App Hub runs a host service inline, on the UI thread (#399). So a slow + file rename counts against the calling script's 64 ms of wall-clock time. + This pull request does not change those paths: `pdf.save`'s commit and + the render cache's write. +- The one-minute load average was 54.8 to 56.9 just after the second + attempt and 74.1 just after the third. Six cargo builds and tests of other + sessions ran at once, the malware scanner took 130 to 200% CPU, and the + media analysis daemon took 150%. Earlier on 10 Oct, at load 15 to 35, this + folder's first round passed all four runs at 64 ms. +- So the four runs above used `--budget-ms 1000`, as #473's fixture run once + did. The first of them stopped in the dark pass: a tap on Combine's Add + files was lost while the card was drawn again. ui.py now taps again while + the list has not shown, and the next run passed all four. diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/README.zh-CN.md b/apps/pdftools/tests/evidence/v2-followups-20261010/README.zh-CN.md new file mode 100644 index 00000000..831d9514 --- /dev/null +++ b/apps/pdftools/tests/evidence/v2-followups-20261010/README.zh-CN.md @@ -0,0 +1,111 @@ +# PDF Tools v2 后续改进的运行记录 — 2026-10-11 + +[English](README.md) | 简体中文 + +[ui.py](../../ui.py) 在这个分支上端到端运行了这些后续改进（macOS，Apple 芯片），当时分支 +位于包含 #478 的 main 07b63dac 之上。之后分支变基到 main bcd52cf4，这只带来了 #484：WASI +套接字，同时 App Hub 的固定版本从 d86101d7 移到 c317f787。变基后没有重新运行。 +[receipt.json](receipt.json) 记录了二进制、包和源文件的摘要、所用命令、每次运行检查的内容、 +观察到的数值，以及未验证的部分。这个文件夹以 10 月 10 日的第一轮命名；这一轮的帧替换了 +那一轮的帧。 + +**隐藏的桌面 Shell，使用真实的 `pdf` 引擎**（`cargo build --locked -p octosense +--no-default-features --features app-hub,craft-engines`，debug 构建）： +- 每次运行使用全新的 `OCTOSENSE_HOME`，其中放有 octosense-pdf-service 的 + `pdftools_fixture` 示例写出的示例 PDF。 +- Shell 从 Terminal.app 标签页启动，带 `MAKEPAD_HIDE_WINDOWS=1`、 + `MAKEPAD_REMOTE=127.0.0.1:8915` 和 `MAKEPAD_WM_TEST_APP=pdftools`。运行时持有本机的 + Shell 运行锁，同一时间只有一个实例，并以 `/quit` 结束。 +- PDF Tools 按自身的窗口尺寸打开（#478）：应用区域为 1292 x 662 点，即宽版布局。每次引擎 + 调用都是真实的。 +- 每一帧都是从原始 `/g` 截图中按应用区域裁出的，每点一个像素。 +- 运行时间是加州 10 月 11 日午夜刚过，比 UTC 晚 7 小时。 +- 这些运行使用 `--budget-ms 1000`，而不是运行时的 64 ms，见下文 + [64 ms 预算](#64-ms-预算)。 + +各帧： +- [light/](light)： + - **01-home**：每个 PDF 的封面来自 `pdf.cover`。状态栏从 `files.status` 读出 + “187 KB of 64 MB used”，当时存储中共有 191,793 字节；仅 PDF 是 38,356 字节，旧的 + 状态栏只统计这一部分。 + - **02c-read-mode、02d-read-mode-zoomed、02e-read-mode-left**：从浮动工具条的最后一个 + 按钮进入阅读模式，位于第 2 页（共 4 页）。 + - 标签页、模式栏、侧栏、面板和状态栏都隐藏了。 + - 工具条保留翻页箭头、“2 / 4”、缩放、适合宽度、适合页面和“Exit read mode”。右上角 + 另有一个退出控件。 + - 然后翻到第 3 页并缩放到 125%。按 Exit read mode 退出后，仍在第 3 页、125%。 + - **03-find、03b-find-done**：在评论面板打开时，在顶栏的搜索框中输入“revenue”。左侧 + 面板显示“9 matches on 4 pages”，侧栏没有任何一项高亮；侧栏本身也没有 Search。按 Done + 后，评论面板恢复。 + - **04-comment、04b-replied**：一处高亮及其回复，日期显示为“Today 00:34”，当时 UTC 是 + 07:34。旧的读法把引擎的 UTC 时间当作本地时间，会显示 07:34。 + - **06-combine、06a-combine-end、06b-combined**：合并中列出两个 PDF。文件列表在卡片 + 内滚动；“One PDF of 5 pages”、Name 和 Combine 按钮不用滚动就一直可见，按钮位于应用 + 662 点高度中的 613 到 659 点之间。此前它在可见区域下方 85 点。然后是合并得到的 PDF。 + - **08-edit、08a-colours、08b-edited**：租约第 1 条，Alignment 选居中，Colour 选红色。 + Colour 框在自己这一行里展开为七个色块：段落原有的颜色和另外六种颜色。按 Apply 后，引擎把 + 这一段画成居中、红色。 + - **09-saved**。 +- [dark/](dark)：切换到 Shell 自己的深色样式后，在浅色一轮留下的状态上重复同样的步骤。 + 因此报告的标签页仍因浅色一轮的高亮而显示为已编辑，合并得到的 PDF 名为 + “Quarterly report combined 2”。 + - **02c-read-mode、02e-read-mode-left**：这次用角落的退出控件离开阅读模式，仍在第 3 页、 + 125%。 + - **03-find**：搜索之前，用侧栏的 Pages 收起了左侧；之后用结果面板自己的关闭按钮结束 + 搜索，左侧再次收起（已检查，没有截图）。 + - **08-edit、08b-edited**：段落设为右对齐，保留它原有的颜色。 +- [restart/](restart)：重启后的同一个主目录。 + - **r01-home、r02-imported**：Shell 运行时保留的封面没有重新绘制，文件和时间都相同；只为 + 两次运行之间放入资料库的 `Imported PDF.pdf` 新画了一个封面。 + - **r03-place-kept**：报告在第 2 页重新打开，正是 Shell 运行结束时的位置。 + - **r04-removed**：移除“Quarterly report combined.pdf”时，它保留的封面也一并删除。提示 + 旁边的卡片是深色一轮生成的“Quarterly report combined 2.pdf”。 +- [full/](full)：存储填到离 64 MiB 只差 8 KB。 + - 状态栏为“63.9 of 64 MB used”，进度条已满并显示为红色。 + - 没有空间存封面，但每张卡片仍显示页数和大小。 + - 移除一个 PDF 时会再问一次，然后移除。 +- [empty/](empty)：没有 PDF，浅色和深色。 + +**App Hub 的 `card-host`**（不提供宿主服务），按设计稿的 1536 x 1024 +（[fixture/](fixture)）。它运行 ui.py 的 `fixture`：包的临时副本使用替身引擎和设计稿中的 +示例文档，先浅色后深色。因为替身引擎在脚本中作答，所以使用 `--budget-ms 1000`。 + +本机的 card-host（App Hub 8347a489）早于清单的 `window` 提示，会拒绝未知的清单字段， +因此临时副本的清单去掉了 `window` 和 `schema_minor`；`main.splash` 与分支中的相同。 + +对比图左边是设计稿、右边是应用，缩小一半并减为 256 色： +- **02-reading**：浮动工具条以阅读模式的按钮结尾。 +- **03-find、d03-find**：只从顶栏发起的搜索界面，浅色和深色。设计稿 03 的侧栏中仍画有 + Search 一项；应用已去掉它，所以侧栏没有任何一项高亮。 +- **06-combine**：在这个高度下，卡片按设计稿 06 完整显示。 +- **08-edit、d08-edit**：Edit 面板中的 Font、Alignment 和 Colour，与设计稿 08 一致。 + +每一帧都已检查过。 + +## 64 ms 预算 + +收到开始运行的指示后，Shell 运行先按运行时的 64 ms 脚本预算进行。 + +- 第一次尝试停在 ui.py 的一个错误上：新的侧栏检查把标签页标题和“Saved”也算了进去。 + 应用是对的，ui.py 已修正。 +- 接下来两次尝试都通过了 Shell 流程中的每个功能步骤，浅色和深色都是。包括阅读模式、 + 从顶栏搜索、一处高亮及其回复、页面、合并、填写与签名、带 Alignment 和 Colour 的编辑、 + 保存以及损坏的文件：共 41 帧，直到 d10-damaged。 +- 两次都只在 ui.py 的日志检查中失败，原因是脚本超出预算，因此 `restart`、`full` 和 + `empty` 没有运行： + - **第二次尝试**记录了两条“script time budget exceeded”，分别位于 `pdf.save` 中 UI 线程 + 停顿 555 ms 的报告之前和之后：停顿来自一次文件重命名，以及随后删除其暂存文件夹。第三次 + 尝试覆盖了它的日志；[run-64ms/attempt-2-excerpt.txt](run-64ms/attempt-2-excerpt.txt) + 保存了在此之前从中读到的几行。 + - **第三次尝试**记录了一条，出现在渲染缓存的文件重命名（`pdf.page`、`cache::store`） + 造成的 262 ms 停顿之后。它的日志是 [run-64ms/shell.log](run-64ms/shell.log) 和 + [run-64ms/ui.log](run-64ms/ui.log)，本机路径已换成占位符。 +- App Hub 在 UI 线程上直接运行宿主服务（#399），所以一次缓慢的文件重命名会计入调用脚本 + 64 ms 的实际耗时。这个拉取请求没有改动这些路径：`pdf.save` 的提交和渲染缓存的写入。 +- 第二次尝试刚结束时，一分钟平均负载为 54.8 到 56.9，第三次刚结束时为 74.1。当时其他会话 + 的六个 cargo 构建和测试同时在运行，恶意软件扫描程序占用 130% 到 200% 的 CPU，媒体分析 + 守护进程占用 150%。10 月 10 日早些时候，在 15 到 35 的负载下，这个文件夹的第一轮在 + 64 ms 下通过了全部四项运行。 +- 因此上面的四项运行使用了 `--budget-ms 1000`，#473 的 fixture 运行也曾这样做。其中第一次 + 在深色一轮中停下：卡片重新绘制时，一次点按合并的 Add files 丢失了。ui.py 现在会在列表 + 出现之前再次点按，下一次运行通过了全部四项。 diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/01-home.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/01-home.png new file mode 100644 index 00000000..d4577854 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/01-home.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/02c-read-mode.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/02c-read-mode.png new file mode 100644 index 00000000..fd24feea Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/02c-read-mode.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/02e-read-mode-left.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/02e-read-mode-left.png new file mode 100644 index 00000000..a81b12f9 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/02e-read-mode-left.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/03-find.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/03-find.png new file mode 100644 index 00000000..714e1384 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/03-find.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/04-comment.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/04-comment.png new file mode 100644 index 00000000..34707c1d Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/04-comment.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/04b-replied.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/04b-replied.png new file mode 100644 index 00000000..4e122f6c Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/04b-replied.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/06-combine.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/06-combine.png new file mode 100644 index 00000000..1a15f8b3 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/06-combine.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/08-edit.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/08-edit.png new file mode 100644 index 00000000..bb518de5 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/08-edit.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/08b-edited.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/08b-edited.png new file mode 100644 index 00000000..4109e096 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/08b-edited.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/dark/09-saved.png b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/09-saved.png new file mode 100644 index 00000000..fe530c20 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/dark/09-saved.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/empty/de01-empty.png b/apps/pdftools/tests/evidence/v2-followups-20261010/empty/de01-empty.png new file mode 100644 index 00000000..936d8fca Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/empty/de01-empty.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/empty/e01-empty.png b/apps/pdftools/tests/evidence/v2-followups-20261010/empty/e01-empty.png new file mode 100644 index 00000000..1a147518 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/empty/e01-empty.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/02-reading.png b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/02-reading.png new file mode 100644 index 00000000..fb564eb1 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/02-reading.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/03-find.png b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/03-find.png new file mode 100644 index 00000000..241a5337 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/03-find.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/06-combine.png b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/06-combine.png new file mode 100644 index 00000000..5fbe9469 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/06-combine.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/08-edit.png b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/08-edit.png new file mode 100644 index 00000000..087d2d39 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/08-edit.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/d03-find.png b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/d03-find.png new file mode 100644 index 00000000..b7b783eb Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/d03-find.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/d08-edit.png b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/d08-edit.png new file mode 100644 index 00000000..c78aee75 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/fixture/d08-edit.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/full/f01-home-full.png b/apps/pdftools/tests/evidence/v2-followups-20261010/full/f01-home-full.png new file mode 100644 index 00000000..a7471078 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/full/f01-home-full.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/full/f02-remove-asks.png b/apps/pdftools/tests/evidence/v2-followups-20261010/full/f02-remove-asks.png new file mode 100644 index 00000000..631c5861 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/full/f02-remove-asks.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/full/f03-removed.png b/apps/pdftools/tests/evidence/v2-followups-20261010/full/f03-removed.png new file mode 100644 index 00000000..fa1e7d44 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/full/f03-removed.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/01-home.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/01-home.png new file mode 100644 index 00000000..bb1a0c26 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/01-home.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/02c-read-mode.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/02c-read-mode.png new file mode 100644 index 00000000..e5a4cf81 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/02c-read-mode.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/02d-read-mode-zoomed.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/02d-read-mode-zoomed.png new file mode 100644 index 00000000..ff5ad009 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/02d-read-mode-zoomed.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/02e-read-mode-left.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/02e-read-mode-left.png new file mode 100644 index 00000000..746f4642 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/02e-read-mode-left.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/03-find.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/03-find.png new file mode 100644 index 00000000..d1fdee17 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/03-find.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/03b-find-done.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/03b-find-done.png new file mode 100644 index 00000000..e08b8464 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/03b-find-done.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/04-comment.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/04-comment.png new file mode 100644 index 00000000..1ce926b2 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/04-comment.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/04b-replied.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/04b-replied.png new file mode 100644 index 00000000..076583e6 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/04b-replied.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/06-combine.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/06-combine.png new file mode 100644 index 00000000..5d08dc59 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/06-combine.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/06a-combine-end.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/06a-combine-end.png new file mode 100644 index 00000000..0c13c98c Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/06a-combine-end.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/06b-combined.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/06b-combined.png new file mode 100644 index 00000000..05e65e0b Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/06b-combined.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/08-edit.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/08-edit.png new file mode 100644 index 00000000..653a6f98 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/08-edit.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/08a-colours.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/08a-colours.png new file mode 100644 index 00000000..60717bf8 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/08a-colours.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/08b-edited.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/08b-edited.png new file mode 100644 index 00000000..33bccbe3 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/08b-edited.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/light/09-saved.png b/apps/pdftools/tests/evidence/v2-followups-20261010/light/09-saved.png new file mode 100644 index 00000000..2f8e261a Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/light/09-saved.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/receipt.json b/apps/pdftools/tests/evidence/v2-followups-20261010/receipt.json new file mode 100644 index 00000000..05268c9f --- /dev/null +++ b/apps/pdftools/tests/evidence/v2-followups-20261010/receipt.json @@ -0,0 +1,253 @@ +{ + "result": "pass", + "date": "2026-10-11", + "scope": "PDF Tools v2 follow-ups end to end: comment dates in local time, the Edit panel's Alignment and Colour, the storage line from files.status, covers kept across closes (pdf.cover), Combine's footer kept in view, one search (in the top bar alone), Read mode (the pages alone), and the review's fixes (page counts and covers after a save, Remove deleting a cover). In a hidden OctoSense desktop shell built from this branch (debug, macOS, Apple silicon), rebased on main with #478, so PDF Tools opened at its own window size (the wide layout), with the real pdf engine in the app's own storage; and in App Hub's card-host with the dev fixture at the designs' 1536 x 1024. Every engine call in the shell runs was real.", + "live_engine": true, + "base": "bcd52cf46b463ff8819e5ad1e64cbe6cb8430b22 (main with #484); the branch was rebased onto it after the runs", + "head": "b75f00d29b43e80c90b9e1591645e9efda5f9c8a (the branch's last commit before this evidence); the sources below are this branch's", + "tested": { + "head": "12e0e4cbed90223f443aa46a640c611ea4263e40, on main 07b63dacf9a66745dfa4900a5d3fd82af24bf757 (with #478, a script app at its manifest's window size; #482, a focused system app as the shell's foreground app; #483)", + "shell_built_from": "94b6f044bf9eaca8142e5c6ab08580785ce50f7c, whose tree differs from the tested head only in apps/pdftools/tests/ui.py, the journeys' driver", + "since": "the rebase onto main bcd52cf4 brought in #484 alone (the same added and removed lines): WASI sockets for app components, and App Hub's pin moved from d86101d7 to c317f787 (catalog 16; WASI sockets admitted; a cancelled host request kept retired when an isolate key is reused; a request's deadline checked again after its response is serialized). The runs were not repeated on it; the pdf service's tests pass on it." + }, + "bundle_blake3": "1da06fa2df33264f49f9e55008b269ac42930ac03c0ad049eff004fe35d3946c", + "shell": { + "binary": "target/debug/octosense (cargo build --locked -p octosense --no-default-features --features app-hub,craft-engines)", + "binary_sha256": "876d4ba980062469a50d34dd3184f7820e2d202df0282883374c2b696ae67d41", + "app_hub_revision": "d86101d7206162b73ea873e2a31b48364600a110 (contract 1.12), the pin the shell was built with; main pins c317f787 since #484", + "runtime": "the root's .sources: makepad d653bc44 with runtime-patches.lock.json's stacked patches, Octoscript-Makepad 6cf2d90a, Octoscript 2e37d9e6", + "launch": "a Terminal.app tab (osascript) under the machine's shell-run lock, one OctoSense at a time: OCTOSENSE_HOME= OCTOS_APP_CORE_DIR=/octos-home/.octos MAKEPAD_HOME=/makepad MAKEPAD_HIDE_WINDOWS=1 MAKEPAD_REMOTE=127.0.0.1:8915 MAKEPAD_WM_TEST_APP=pdftools; ended with /quit", + "script_budget": "MAKEPAD_SPLASH_BUDGET_MS=1000 (--budget-ms 1000) for the four evidence runs; see run_64ms for the runs at the runtime's 64 ms and why", + "window": "PDF Tools at its own window size (#478): an app area of 1292 x 662 points in the 1400 x 898 hidden shell, the wide layout", + "time_zone": "America/Los_Angeles (PDT, UTC-7): the evidence runs were just after midnight on 11 Oct, 7 hours behind UTC, so the old UTC reading would have shown each mark 7 hours later" + }, + "card_host": { + "binary_sha256": "760bb822435d578d69b89c39d7f25a8f8dafc1851a1911687efc0f483df895ec", + "app_hub_revision": "8347a489141c0e24cab564883db7c4592935a8b2 (the one on this machine; it predates the manifest's window hint)", + "manifest": "the scratch copy's manifest drops `window` and `schema_minor`, which this card-host refuses as unknown keys; main.splash and the rest of the bundle are the branch's own", + "size": "1536 x 1024 (--size), MAKEPAD_WIDGET_STYLE=macos and macos-dark", + "script_budget": "MAKEPAD_SPLASH_BUDGET_MS=1000: the stand-in engine answers in script" + }, + "source_sha256": { + "apps/pdftools/bundle/main.splash": "39801504143dcb670252d9e3167deb0283c2f361962e11627d115c61a083a3e9", + "apps/pdftools/bundle/manifest.json": "3c062555c5521ec7de41a0c2c86b1bac75be0d005cd7727f9d32c55535000236", + "apps/pdftools/tests/ui.py": "19b8e4c92de2b37535b4b4339dd2b13e9115d65cc7f059a445774ceaea55d593", + "apps/pdftools/dev-fixture/engine.splash": "b9a3d9759a5607dc7ca3e4984fd72ac99bdcf3db99504b0fa7ea3e773fc542d4", + "apps/pdftools/dev-fixture/make_fixture.py": "92541102e942d7af8ff45fff33a8885a1a8ef6c47efa76d812e89b5218d53614", + "apps/pdf/host-service/examples/pdftools_fixture.rs": "f44ad5a202da98b4a07468e9dccdff59f7e2b333edec6e879245a3b7491307fc", + "apps/pdftools/design/SERVICE.md": "d3959995765cd53010452ea9811bc094cf627064a865c55d21648124cc12e7b9", + "apps/pdf/host-service/src/review.rs": "9a75b9548958a95c223b514b91541aff7348e886f7d170a79b1dfbe12a036414", + "apps/pdf/host-service/src/dates.rs": "0590244f3ca006adb59107ca201a6be424e3a85d122495bad55b2e581626e714", + "apps/pdf/host-service/src/change.rs": "226b188c08425e173de2583ad80c88140202dedd757d8072da15564e0d48f563", + "apps/pdf/host-service/src/covers.rs": "a391029db168f272dfbd6e670c09a595081cad834febd3164bbe8358fe1be300", + "apps/pdf/host-service/src/cache.rs": "7f4d6d2a8de28ffb1a92b5c582c1476149cd7d711787e2afcb6067b183dc6dd2", + "crates/shell/src/files_service/mod.rs": "74df96648bdca7a0dbe64116addcab48643e6295a44aaafdb443c5992889eb9f" + }, + "commands": [ + "python3 tools/setup.py", + "cargo test --locked -p octosense-pdf-service", + "cargo clippy --locked -p octosense-pdf-service --all-targets --no-deps -- -D warnings", + "(from phone/) cargo test --locked --features mobile-apps -p octosense-shell (1,185 passed, the 19 pdftools_model and the files_service tests among them)", + "python3 tools/setup.py --check --cargo; python3 tools/native_apps.py --check", + "(from desktop/) bash ../tools/check-shell-graph.sh -p octosense; (from phone/) bash ../tools/check-shell-graph.sh -p octosense-home; (from rom/) python3 -m unittest tests.test_no_local_paths", + "cargo build --locked -p octosense --no-default-features --features app-hub,craft-engines", + "python3 apps/pdftools/tests/ui.py --shell target/debug/octosense --lock /octosense-shell.lock --output /ui-go --only shell --only restart --only full --only empty (the runtime's 64 ms: see run_64ms)", + "python3 apps/pdftools/tests/ui.py --shell target/debug/octosense --lock /octosense-shell.lock --budget-ms 1000 --output /ui-1000 --only shell --only restart --only full --only empty", + " /fixture_run.py --card-host /target/release/card-host --only fixture --budget-ms 1000 --output /ui-fixture (ui.py's card-host run; the wrapper only drops `window` and `schema_minor` from the scratch bundle's manifest)", + "hub stamp ; hub check --system-app (the same two findings as main's bundle: no store listing, unsigned; nothing new)", + "frames: the app's area cut from each shell grab by its sidecar (one pixel per point); card-host side-by-sides halved and reduced to 256 colours (PIL)", + "after the rebase onto bcd52cf4: python3 tools/setup.py; python3 tools/setup.py --check --cargo; python3 tools/native_apps.py --check; cargo test --locked -p octosense-pdf-service (56 + 1 + 1 passed, at App Hub c317f787)" + ], + "runs": { + "shell": "the samples, light, then dark through the shell's style menu, the dark pass on what the light pass left", + "restart": "the same home again, with Imported PDF.pdf (pdftools_fixture --import-sample) placed in the library between the runs", + "full": "a fresh home whose storage was filled to 8 KB short of 64 MiB", + "empty": "a fresh home with no PDFs, light then dark", + "fixture": "card-host, a scratch copy of the bundle with dev-fixture/engine.splash in place of engine(), make_fixture.py's documents, 1536 x 1024, light then dark" + }, + "run_64ms": { + "result": "every functional step passed, light and dark; the log check failed on script budget overruns", + "summary": "After the go, the shell journey ran at the runtime's 64 ms script budget. The first attempt stopped at a test bug, the new rail check also counting the tab title and 'Saved' (fixed in ui.py; the app was right). The next two attempts passed every functional step of the shell journey, light and dark: Read mode (enter, turn a page, zoom, exit on the same page and zoom), find from the top bar alone with the left panel given back, a highlight and its reply, Pages, Combine, Fill & Sign, Edit with Alignment and Colour, save, and the damaged file (41 frames, through d10-damaged). Each then failed only the log check (check_log), on script budget overruns, and so restart, full and empty did not run.", + "overruns": [ + "the second attempt (23:56 to 23:59 on 10 Oct, California time): two 'script time budget exceeded' (its log's lines 1200 and 1215) around a 555 ms UI-thread stall in pdf.save, reported at line 1214: a file rename (octosense_engine_area::Stage::commit), then the removal of its staging folder. The third attempt overwrote that log; run-64ms/attempt-2-excerpt.txt holds the lines read from it before then", + "the third attempt (00:14 to 00:17 on 11 Oct): one, logged after a 262 ms UI-thread stall in the render cache's file rename (pdf.page, cache::store, Area::write), with only image decoding in between; its logs are kept, sanitized, in run-64ms/" + ], + "cause": "App Hub dispatches a host service inline from host.request, on the UI thread (#399), so a slow file rename counts against the calling script's 64 ms wall-clock budget. Those service paths (pdf.save's commit, the render cache's write) are unchanged by this pull request.", + "load": "the one-minute load average was 54.8 to 56.9 just after the second attempt and 74.1 just after the third: six cargo builds and tests of other sessions at once, the malware scanner at 130 to 200% CPU, and the media analysis daemon at 150%. The evidence runs at --budget-ms 1000 ended at 10.7. Earlier on 10 Oct, at load 15 to 35, this folder's first round (before Read mode, one search and the review's fixes) passed all four runs at 64 ms with no overrun; its receipt is in this branch's history.", + "decision": "the four evidence runs that follow used --budget-ms 1000, as #473's fixture run once did", + "log": "run-64ms/shell.log and run-64ms/ui.log: the third attempt's shell and driver logs, with machine-local paths replaced by placeholders; run-64ms/attempt-2-excerpt.txt: the second attempt's error and hang lines, read from its log before the third attempt overwrote it" + }, + "runs_1000ms": [ + "first: stopped in the dark pass's Combine, when a tap on Add files was lost while the card was drawn again ('could not scroll Board minutes.pdf into view'); ui.py's open_add_list now taps again while no PDF of the list shows (commit 'PDF Tools journeys: Combine's Add files tapped until its list shows')", + "second: all four runs passed; its frames and numbers are the ones here" + ], + "observed": { + "storage_line": { + "shown": [ + 191488.0, + 64 + ], + "jail_bytes": 191793, + "library_pdf_bytes": 38356 + }, + "read_mode": [ + { + "pass": "light", + "entered_on": "2 / 4", + "left_on": "3 / 4", + "zoom": [ + 1.0, + 1.25 + ], + "left_by": "Exit read mode" + }, + { + "pass": "dark", + "entered_on": "2 / 4", + "left_on": "3 / 4", + "zoom": [ + 1.0, + 1.25 + ], + "left_by": "corner control" + } + ], + "comment_dates": [ + { + "pass": "light", + "utc_now": "2026-10-11T07:34Z", + "shown_one_of": [ + "Today 00:34" + ] + }, + { + "pass": "dark", + "utc_now": "2026-10-11T07:36Z", + "shown_one_of": [ + "Today 00:36" + ] + } + ], + "combine_button": [ + { + "pass": "light", + "area": [ + 54, + 76, + 1292, + 662 + ], + "button": [ + 937, + 613, + 140, + 46 + ] + }, + { + "pass": "dark", + "area": [ + 54, + 76, + 1292, + 662 + ], + "button": [ + 937, + 613, + 140, + 46 + ] + } + ], + "covers_after_shell_run": [ + "529d0969fe6aecff-16477-1791704063249397407@48.png", + "613ca0035b985603-10535-1791704180365964927@48.png", + "af4c8071f14d2a8a-5732-1791704063249161945@48.png", + "daec677dceec21c2-9551-1791704063248932692@48.png", + "e135281299f25e61-10534-1791704112285385685@48.png", + "f0b4f225a4635b83-83406-1791704195598396890@48.png" + ], + "removed_with_its_cover": { + "pdf": "Quarterly report combined.pdf", + "cover": ".cache/covers/e135281299f25e61-10534-1791704112285385685@48.png" + }, + "covers_after_restart": { + "kept_untouched": [ + "529d0969fe6aecff-16477-1791704063249397407@48.png", + "613ca0035b985603-10535-1791704180365964927@48.png", + "af4c8071f14d2a8a-5732-1791704063249161945@48.png", + "daec677dceec21c2-9551-1791704063248932692@48.png", + "f0b4f225a4635b83-83406-1791704195598396890@48.png" + ], + "drawn_now": [ + "9bbd32ca74ee02a3-5053-1791704205378124363@48.png" + ], + "gone_now": [ + "e135281299f25e61-10534-1791704112285385685@48.png" + ] + } + }, + "checks": [ + "Storage line: Home said '187 KB of 64 MB used' while the app's storage held 191793 bytes (files.status used_bytes and quota_bytes); its PDFs alone were 38356 bytes, what the old line counted", + "Comment dates: the highlight made in each pass, and its reply, read 'Today 00:34' (UTC 2026-10-11T07:34Z) and 'Today 00:36' (UTC 2026-10-11T07:36Z): this machine's local time, where the engine stamps UTC (the old reading showed the UTC wall clock, 7 hours later, and after 17:00 the next day)", + "Edit (design 08): clause 1 of the lease with Alignment centred and Colour Red (the box opened into seven chips: the paragraph's own colour and six others), applied: the engine drew it centred and red; the dark pass set it flush right in its own colour", + "Combine: with two PDFs listed, the card's own Combine button stayed in view with no scroll (light: [937, 613, 140, 46] in the app area [54, 76, 1292, 662]; dark: [937, 613, 140, 46] in the app area [54, 76, 1292, 662]); the list scrolls inside the card; before, the button sat 85 points below the fold at this size", + "Covers: after the shell run, one cover per PDF in .cache/covers (6), each named in library.json; the restart drew none of the 5 current covers again (the same files and times) and drew one for the new import", + "Full storage: '63.9 of 64 MB used' with the bar full; no room for a cover, each card still shows its pages and size; removing a PDF works", + "One search: the rail offers Pages, Outline and Comments (no Search); Search in document opens the results in the left panel ('9 matches on 4 pages'); in the light pass Done gave back the Comments panel open before the search, in the dark pass the results' own cross folded the left side again, as it was", + "Read mode: light: entered from the floating bar on 2 / 4, the tabs, mode bar, rail, panels and status line gone, a page turned to 3 / 4 and the zoom changed 100% to 125%, left by the bar's Exit read mode on 3 / 4 at 125%; dark: entered from the floating bar on 2 / 4, the tabs, mode bar, rail, panels and status line gone, a page turned to 3 / 4 and the zoom changed 100% to 125%, left by the corner control on 3 / 4 at 125%", + "Remove: 'Quarterly report combined.pdf' removed from Home after the restart took its kept cover (.cache/covers/e135281299f25e61-10534-1791704112285385685@48.png) with it", + "Design size (card-host, 1536 x 1024): reading (02) with Read mode's button ending the floating bar; the find screen (03-find, d03-find) from the top bar alone, with no Search in the rail (design 03 still draws one); Combine's card fits as designed; the Edit panel shows Font, Alignment and Colour as design 08 draws them", + "No script errors in the evidence runs' logs (check_log): the shell runs at --budget-ms 1000, the fixture run at MAKEPAD_SPLASH_BUDGET_MS=1000; see run_64ms for the runtime's 64 ms" + ], + "not_verified": [ + "Linux and Windows (the pdf engine is desktop-only; Windows's offset path, chrono's Local, was not built here); phones", + "after the rebase onto #484: these runs, the shell suite and the desktop build (before it, on 94b6f044, the shell suite passed and the desktop built; after it, setup's checks and the pdf service's tests pass)", + "restart, full and empty at the runtime's 64 ms in this round: the shell run's overruns stopped each 64 ms attempt before them", + "card-host at App Hub's current pin: the one on this machine predates the window hint", + "the host's file dialog and a real import (a hidden window cannot open it)" + ], + "grabs": [ + "dark/01-home.png", + "dark/02c-read-mode.png", + "dark/02e-read-mode-left.png", + "dark/03-find.png", + "dark/04-comment.png", + "dark/04b-replied.png", + "dark/06-combine.png", + "dark/08-edit.png", + "dark/08b-edited.png", + "dark/09-saved.png", + "empty/de01-empty.png", + "empty/e01-empty.png", + "fixture/02-reading.png", + "fixture/03-find.png", + "fixture/06-combine.png", + "fixture/08-edit.png", + "fixture/d03-find.png", + "fixture/d08-edit.png", + "full/f01-home-full.png", + "full/f02-remove-asks.png", + "full/f03-removed.png", + "light/01-home.png", + "light/02c-read-mode.png", + "light/02d-read-mode-zoomed.png", + "light/02e-read-mode-left.png", + "light/03-find.png", + "light/03b-find-done.png", + "light/04-comment.png", + "light/04b-replied.png", + "light/06-combine.png", + "light/06a-combine-end.png", + "light/06b-combined.png", + "light/08-edit.png", + "light/08a-colours.png", + "light/08b-edited.png", + "light/09-saved.png", + "restart/r01-home.png", + "restart/r02-imported.png", + "restart/r03-place-kept.png", + "restart/r04-removed.png" + ] +} diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r01-home.png b/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r01-home.png new file mode 100644 index 00000000..ea4561be Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r01-home.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r02-imported.png b/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r02-imported.png new file mode 100644 index 00000000..28fff2a3 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r02-imported.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r03-place-kept.png b/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r03-place-kept.png new file mode 100644 index 00000000..70b1a3b0 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r03-place-kept.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r04-removed.png b/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r04-removed.png new file mode 100644 index 00000000..14cac381 Binary files /dev/null and b/apps/pdftools/tests/evidence/v2-followups-20261010/restart/r04-removed.png differ diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/attempt-2-excerpt.txt b/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/attempt-2-excerpt.txt new file mode 100644 index 00000000..6ba521c8 --- /dev/null +++ b/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/attempt-2-excerpt.txt @@ -0,0 +1,19 @@ +The shell run's second attempt at the runtime's 64 ms script budget, from +23:56 to 23:59 on 10 Oct 2026 in California (06:56 to 06:59 UTC on 11 Oct; +the one-minute load average was 56.89 right after). It passed every +functional step of the shell journey, light and dark (41 frames, through +d10-damaged), then failed ui.py's log check. The third attempt overwrote its +shell log, so these lines, read from it before then, are all that is left. + +ui.py's check_log listed two errors: + +[E] splash:36899311104:1174:10 - script time budget exceeded (.sources/makepad/platform/script/src/vm.rs:1230) +[E] splash:36899311104:1174:10 - script time budget exceeded (.sources/makepad/platform/script/src/vm.rs:1230) + +Read with grep -n -B3 (the numbers are the log's own lines; image-decoding +lines that grep printed as context are left out). The second error is at +line 1215, the line after the hang report, but it was cut from what was read. + +1200:[E] splash:36899311104:1174:10 - script time budget exceeded (.sources/makepad/platform/script/src/vm.rs:1230) +1213-[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 92 jobs, peak queue light 1 / heavy 1; light 91: wait avg 0.29 ms max 12.98 ms, run avg 6.3 ms max 37.0 ms; heavy 1: wait avg 0.04 ms max 0.04 ms, run avg 0.0 ms max 0.0 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 49 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=49 max=37.00ms] overflow=0; heavy >250ms offenders=[] +1214-[I] .sources/makepad/platform/src/thread/ui_hang/native.rs:88:46 - [ui-hang] 555 ms · phase=Signal detail=0 · samples=4 · ticks=4/expected=5 · top frames: 2x Signal: __rename+0x8 (libsystem_kernel.dylib) ← std::sys::fs::rename+0xcc (octosense) ← octosense_engine_area::Stage::commit+0x230 (octosense) ← octosense_pdf_service::change::commit+0x90 (octosense) ← std::thread::local::LocalKey::>::with::::{closure:#0}, core::result::Result::>+0x914 (octosense) ← octosense_pdf_service::docs::with_doc::+0xf8 (octosense) ← octosense_pdf_service::change::save+0xf0 (octosense) ← ::call+0x1e4 (octosense) | 1x Signal: __openat+0x8 (libsystem_kernel.dylib) ← std::sys::fs::unix::remove_dir_impl::remove_dir_all_recursive+0x50 (octosense) ← std::sys::fs::remove_dir_all+0xdc (octosense) ← ::drop+0x10 (octosense) ← core::ptr::drop_glue::+0x14 (octosense) ← std::thread::local::LocalKey::>::with::::{closure:#0}, core::result::Result::>+0xb98 (octosense) ← octosense_pdf_service::docs::with_doc::+0xf8 (octosense) ← octosense_pdf_service::change::save+0xf0 (octosense) | 1x Signal: __unlinkat+0x8 (libsystem_kernel.dylib) ← std::sys::fs::unix::remove_dir_impl::remove_dir_all_recursive+0x2e0 (octosense) ← std::sys::fs::remove_dir_all+0xdc (octosense) ← ::drop+0x10 (octosense) ← core::ptr::drop_glue::+0x14 (octosense) ← std::thread::local::LocalKey::>::with::::{closure:#0}, core::result::Result::>+0xb98 (octosense) ← octosense_pdf_service::docs::with_doc::+0xf8 (octosense) ← octosense_pdf_service::change::save+0xf0 (octosense) diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/shell.log b/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/shell.log new file mode 100644 index 00000000..eb4c890c --- /dev/null +++ b/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/shell.log @@ -0,0 +1,1230 @@ +[I] .sources/makepad/platform/src/web_socket.rs:330:13 - studio websocket disabled: empty studio_http +[makepad-remote] listening on 127.0.0.1:8915 pid=85794 app=octosense grabs=/makepad-remote/octosense-85794 +[I] .sources/makepad/platform/src/remote.rs:550:9 - [makepad-remote] listening on 127.0.0.1:8915 pid=85794 app=octosense grabs=/makepad-remote/octosense-85794 +[I] .sources/makepad/platform/src/os/apple/metal.rs:3100:9 - retained-upload budgets: recommended_working_set_bytes=115448725504 physical_memory_bytes=137438953472 unified=true allocation_limit=17179869184 fraction=1/4 pool_fraction=1/16 residency_high_fraction=3/4 residency_low_fraction=5/8 source=physicalMemory/2 +[I] .sources/makepad/platform/src/cx.rs:689:9 - memory budget: 65536 MiB (ProcessInfo.processInfo.physicalMemory) +[I] .sources/makepad/platform/src/thread.rs:928:9 - UI thread priority UserInteractive: Applied +[I] crates/ai-host/src/lib.rs:395:13 - llm: provider profile under /pdftools-shell-hqw08mg5/home/octos-home/.octos +[I] crates/ai-host/src/lib.rs:429:5 - model: service registered (one-shot calls; admitted apps only) +[I] crates/shell/src/octosense/paths.rs:86:13 - rinx: data folder /pdftools-shell-hqw08mg5/home/apps/rinx/data (under OCTOSENSE_HOME) +[I] crates/shell/src/lib.rs:6051:9 - wm: modules linked: ["apphub", "card"] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1672 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 941 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:30:5 - Encountered unknown chunk "caBX" +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:31:5 - Length of chunk 23617 +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:32:5 - Skipping 23621 bytes +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1672 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 941 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:30:5 - Encountered unknown chunk "caBX" +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:31:5 - Length of chunk 23617 +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:32:5 - Skipping 23621 bytes +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGB +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGB +[I] crates/shell/src/desktop_app.rs:207:9 - wm: desktop style octosense applied to 0 clients and 0 modules +[I] crates/shell/src/lib.rs:6083:13 - octosense: background app prewarming disabled +[I] crates/shell/src/apps.rs:467:13 - news: service registered, host dir /pdftools-shell-hqw08mg5/home/apps/.host +[I] crates/shell/src/apps.rs:396:9 - glance: the notice service answers ["os.maps", "os.ai-providers", "os.youtube", "os.quickdeck", "os.pdftools", "os.writer"] (no service of their own) +[I] /git/checkouts/rinx-cf0dcd4e7b4d3fa8/4b89097/crates/article-makepad/src/apple_fonts.rs:85:5 - Apple typography: PingFang SC Regular/Semibold for English and Chinese; bundled fallback retained +[I] crates/shell/src/module_host.rs:697:9 - wm: module instance card.1 for client 1 in isolate SplashVmId(1) (scope i1g1) +[I] crates/shell/src/lib.rs:2654:13 - wm: pdftools asks for a 1536x1024 window; it opens at 1296x698 (the dock covers 78 points of the desk) +[I] crates/shell/src/lib.rs:2673:9 - wm: launched pdftools as client 1 (in-process, card) +[I] /git/checkouts/octosense-app-hub-3222614192ecfbf8/d86101d/crates/appstore/src/cardapp.rs:134:9 - card: os.pdftools running under 3 capability(ies), 1 host(s), 67108864 bytes of storage, 4000000000 instructions, 134217728 bytes of heap +[I] /git/checkouts/rinx-cf0dcd4e7b4d3fa8/4b89097/crates/article-makepad/src/apple_fonts.rs:85:5 - Apple typography: PingFang SC Regular/Semibold for English and Chinese; bundled fallback retained +[I] /git/checkouts/rinx-cf0dcd4e7b4d3fa8/4b89097/crates/article-makepad/src/apple_fonts.rs:85:5 - Apple typography: PingFang SC Regular/Semibold for English and Chinese; bundled fallback retained +[I] .sources/makepad/widgets/src/splash.rs:420:9 - [SPLASH] eval: 187046 bytes preserve=false view=true animating=false tick=false epoch=0 +[I] .sources/makepad/platform/src/thread/ui_hang/native.rs:88:46 - [ui-hang] 1482 ms · phase=Startup detail=0 · samples=18 · ticks=18/expected=20 · top frames: 8x Startup: __open+0x8 (libsystem_kernel.dylib) ← std::sys::fs::unix::File::open_c+0x10c (octosense) ← std::fs::read_to_string::inner+0xc0 (octosense) ← std::fs::read_to_string::+0x1c (octosense) ← octosense_appstore::system::admit_directory+0x54 (octosense) ← octosense_appstore::system::prepare+0x7e8 (octosense) ← octosense_shell::host_tools::script_apps::admitted_bundle+0xf8 (octosense) ← octosense_shell::host_tools::script_apps::guidance+0x1c (octosense) | 4x Startup: __open+0x8 (libsystem_kernel.dylib) ← std::sys::fs::unix::File::open_c+0x10c (octosense) ← std::fs::read::inner+0xbc (octosense) ← std::fs::read::+0x1c (octosense) ← octosense_app_contract::bundle::digest_dir+0x2ac (octosense) ← octosense_appstore::system::admit_directory+0x104 (octosense) ← octosense_appstore::system::prepare+0x7e8 (octosense) ← octosense_shell::apps::window_hint+0x194 (octosense) | 1x Startup: mkdir+0x8 (libsystem_kernel.dylib) ← octosense_shell::app_storage::ensure_private_dir+0x1ac (octosense) ← octosense_shell::mail_background::directory+0xe0 (octosense) ← octosense_shell::mail_background::active+0x50 (octosense) ← octosense_shell::mail_background::restore_publications+0xd0 (octosense) ← octosense_shell::glance::expire_now+0x2c (octosense) ← octosense_shell::glance::listed+0x24 (octosense) ← octosense_shell::App::update_bar+0xb44 (octosense) | 1x Startup: __open+0x8 (libsystem_kernel.dylib) ← std::sys::fs::unix::File::open_c+0x10c (octosense) ← std::fs::read_to_string::inner+0xc0 (octosense) ← std::fs::read_to_string::+0x1c (octosense) ← makepad_widgets::desktop_style::StyleSheet::load_with_appearance::{closure:#0}+0x88 (octosense) ← makepad_widgets::desktop_style::StyleSheet::load_with_appearance+0x1d4 (octosense) ← makepad_widgets::desktop_style::current+0x124 (octosense) ← makepad_widgets::desktop_style::apply_theme+0x1c (octosense) +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 32 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 32 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 64 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 64 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 128 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 128 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 256 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 256 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 512 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 512 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1024 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1024 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] /git/checkouts/rinx-cf0dcd4e7b4d3fa8/4b89097/crates/article-makepad/src/apple_fonts.rs:85:5 - Apple typography: PingFang SC Regular/Semibold for English and Chinese; bundled fallback retained +[I] /git/checkouts/rinx-cf0dcd4e7b4d3fa8/4b89097/crates/article-makepad/src/apple_fonts.rs:85:5 - Apple typography: PingFang SC Regular/Semibold for English and Chinese; bundled fallback retained +[I] .sources/makepad/widgets/src/splash.rs:420:9 - [SPLASH] eval: 809 bytes preserve=false view=true animating=false tick=false epoch=0 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 216 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 216 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] /git/checkouts/rinx-cf0dcd4e7b4d3fa8/4b89097/crates/article-makepad/src/apple_fonts.rs:85:5 - Apple typography: PingFang SC Regular/Semibold for English and Chinese; bundled fallback retained +[I] .sources/makepad/platform/src/thread/ui_hang/native.rs:88:46 - [ui-hang] 269 ms · phase=native-event detail=0 · samples=0 · ticks=0/expected=0 · top frames: +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] crates/shell/src/apps.rs:455:13 - news: fetched 185 new, 185 kept, 7 sources (0 failed) +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 6 jobs, peak queue light 1 / heavy 1; light 5: wait avg 0.02 ms max 0.06 ms, run avg 5.0 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 1 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=1 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 7 jobs, peak queue light 1 / heavy 1; light 5: wait avg 0.02 ms max 0.06 ms, run avg 5.0 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 1 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=1 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 14 jobs, peak queue light 1 / heavy 1; light 13: wait avg 0.02 ms max 0.06 ms, run avg 4.5 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 5 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=5 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1488 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 2105 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1488 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 2105 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1488 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 2105 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1488 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 2105 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 16 jobs, peak queue light 1 / heavy 1; light 15: wait avg 0.02 ms max 0.06 ms, run avg 5.6 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 7 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=7 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 19 jobs, peak queue light 1 / heavy 1; light 18: wait avg 0.02 ms max 0.06 ms, run avg 6.1 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 10 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=10 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 20 jobs, peak queue light 1 / heavy 1; light 18: wait avg 0.02 ms max 0.06 ms, run avg 6.1 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 10 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=10 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 24 jobs, peak queue light 1 / heavy 1; light 23: wait avg 0.02 ms max 0.06 ms, run avg 5.3 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 11 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=11 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 27 jobs, peak queue light 1 / heavy 1; light 25: wait avg 0.02 ms max 0.06 ms, run avg 5.0 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 11 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=11 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 29 jobs, peak queue light 1 / heavy 1; light 28: wait avg 0.02 ms max 0.06 ms, run avg 4.6 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 11 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=11 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 39 jobs, peak queue light 1 / heavy 1; light 38: wait avg 0.02 ms max 0.06 ms, run avg 4.7 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 16 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=16 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 48 jobs, peak queue light 1 / heavy 1; light 47: wait avg 0.02 ms max 0.06 ms, run avg 4.9 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 21 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=21 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 50 jobs, peak queue light 1 / heavy 1; light 49: wait avg 0.02 ms max 0.06 ms, run avg 5.2 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 23 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=23 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 51 jobs, peak queue light 1 / heavy 1; light 50: wait avg 0.02 ms max 0.06 ms, run avg 5.3 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 24 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=24 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 52 jobs, peak queue light 1 / heavy 1; light 51: wait avg 0.02 ms max 0.06 ms, run avg 5.2 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 24 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=24 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1672 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 941 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:30:5 - Encountered unknown chunk "caBX" +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:31:5 - Length of chunk 21844 +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:32:5 - Skipping 21848 bytes +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1672 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 941 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:30:5 - Encountered unknown chunk "caBX" +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:31:5 - Length of chunk 21844 +[I] .sources/makepad/libs/zune/zune-png/src/options.rs:32:5 - Skipping 21848 bytes +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGB +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGB +[I] crates/shell/src/desktop_app.rs:207:9 - wm: desktop style octosense-dark applied to 1 clients and 1 modules +[I] /git/checkouts/rinx-cf0dcd4e7b4d3fa8/4b89097/crates/article-makepad/src/apple_fonts.rs:85:5 - Apple typography: PingFang SC Regular/Semibold for English and Chinese; bundled fallback retained +[I] .sources/makepad/widgets/src/splash.rs:420:9 - [SPLASH] eval: 187046 bytes preserve=true view=false animating=false tick=false epoch=0 +[I] /git/checkouts/rinx-cf0dcd4e7b4d3fa8/4b89097/crates/article-makepad/src/apple_fonts.rs:85:5 - Apple typography: PingFang SC Regular/Semibold for English and Chinese; bundled fallback retained +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 53 jobs, peak queue light 1 / heavy 1; light 52: wait avg 0.02 ms max 0.06 ms, run avg 5.4 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 25 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=25 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 54 jobs, peak queue light 1 / heavy 1; light 52: wait avg 0.02 ms max 0.06 ms, run avg 5.4 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 25 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=25 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 61 jobs, peak queue light 1 / heavy 1; light 60: wait avg 0.02 ms max 0.06 ms, run avg 5.4 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 29 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=29 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1488 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 2105 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1488 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 2105 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1488 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 2105 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1488 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 2105 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 63 jobs, peak queue light 1 / heavy 1; light 62: wait avg 0.02 ms max 0.06 ms, run avg 5.7 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 31 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=31 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 66 jobs, peak queue light 1 / heavy 1; light 65: wait avg 0.02 ms max 0.12 ms, run avg 6.0 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 34 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=34 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 67 jobs, peak queue light 1 / heavy 1; light 65: wait avg 0.02 ms max 0.12 ms, run avg 6.0 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 34 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=34 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 68 jobs, peak queue light 1 / heavy 1; light 67: wait avg 0.06 ms max 3.05 ms, run avg 6.0 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 35 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=35 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 73 jobs, peak queue light 1 / heavy 1; light 72: wait avg 0.07 ms max 3.05 ms, run avg 5.7 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 37 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=37 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 74 jobs, peak queue light 1 / heavy 1; light 72: wait avg 0.07 ms max 3.05 ms, run avg 5.7 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 37 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=37 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread/ui_hang/native.rs:88:46 - [ui-hang] 262 ms · phase=Timer detail=0 · samples=1 · ticks=1/expected=0 · top frames: 1x Timer: __rename+0x8 (libsystem_kernel.dylib) ← std::sys::fs::rename+0xcc (octosense) ← octosense_engine_area::Area::write+0x5f4 (octosense) ← octosense_pdf_service::cache::store+0x31c (octosense) ← std::thread::local::LocalKey::>::with::::{closure:#0}, core::result::Result::>+0x9ac (octosense) ← octosense_pdf_service::docs::with_doc::+0xfc (octosense) ← octosense_pdf_service::reading::page+0x1f8 (octosense) ← ::call+0x1e4 (octosense) +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 85 jobs, peak queue light 1 / heavy 1; light 83: wait avg 0.07 ms max 3.05 ms, run avg 5.9 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 42 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=42 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[E] splash:36369862144:1174:10 - script time budget exceeded (.sources/makepad/platform/script/src/vm.rs:1230) +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1182 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1673 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 199 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 281 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 89 jobs, peak queue light 1 / heavy 1; light 88: wait avg 0.10 ms max 3.05 ms, run avg 6.0 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 45 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=45 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 91 jobs, peak queue light 1 / heavy 1; light 90: wait avg 0.10 ms max 3.05 ms, run avg 6.1 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 47 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=47 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 1190 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 1684 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 92 jobs, peak queue light 1 / heavy 1; light 91: wait avg 0.10 ms max 3.05 ms, run avg 6.2 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 48 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=48 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:110:9 - Width: 397 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:111:9 - Height: 562 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:112:9 - Filter type:None +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:113:9 - Depth: 8 +[I] .sources/makepad/libs/zune/zune-png/src/headers/readers.rs:114:9 - Interlace :Standard +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:625:9 - Input Colorspace: RGBA +[I] .sources/makepad/libs/zune/zune-png/src/decoder.rs:626:9 - Output Colorspace: RGBA +[I] .sources/makepad/platform/src/thread.rs:1363:13 - pool: 6 workers (2 light-only, 6 started), 93 jobs, peak queue light 1 / heavy 1; light 92: wait avg 0.10 ms max 3.05 ms, run avg 6.2 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 48 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=48 max=20.82ms] overflow=0; heavy >250ms offenders=[] +[makepad-remote] remote quit +[I] .sources/makepad/platform/src/thread.rs:942:13 - pool: 6 workers (2 light-only, 6 started), 93 jobs, peak queue light 1 / heavy 1; light 92: wait avg 0.10 ms max 3.05 ms, run avg 6.2 ms max 20.8 ms; heavy 1: wait avg 0.13 ms max 0.13 ms, run avg 0.1 ms max 0.1 ms; priority applied 6/6 (light UserInitiated / heavy Utility); light >2ms 48 offenders=[makepad_platform::thread::TaskQueue::pump::{{closure}} count=48 max=20.82ms] overflow=0; heavy >250ms offenders=[] diff --git a/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/ui.log b/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/ui.log new file mode 100644 index 00000000..bab6a9b1 --- /dev/null +++ b/apps/pdftools/tests/evidence/v2-followups-20261010/run-64ms/ui.log @@ -0,0 +1,68 @@ +homes in /pdftools-shell-hqw08mg5 +warning: method `update_native_dpi_factor` is never used + --> .sources/makepad/platform/src/window.rs:893:19 + | +833 | impl CxWindow { + | ------------- method in this implementation +... +893 | pub(crate) fn update_native_dpi_factor(&mut self, density: f64) -> Option<(WindowGeom, WindowGeom)> { + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default + +Wrote /pdftools-shell-hqw08mg5/home/apps/os.pdftools/accounts/device/library + /ui-go/shell/01-home.png + /ui-go/shell/01b-open-from-device.png + /ui-go/shell/02-reading.png + /ui-go/shell/02b-page-2.png + /ui-go/shell/02c-read-mode.png + /ui-go/shell/02d-read-mode-zoomed.png + /ui-go/shell/02e-read-mode-left.png + /ui-go/shell/03-find.png + /ui-go/shell/03b-find-done.png + /ui-go/shell/04-comment.png + /ui-go/shell/04b-replied.png + /ui-go/shell/05-pages-rotated.png + /ui-go/shell/05b-undone.png + /ui-go/shell/06-combine.png + /ui-go/shell/06a-combine-end.png + /ui-go/shell/06b-combined.png + /ui-go/shell/07-fill-sign.png + /ui-go/shell/08a-colours.png + /ui-go/shell/08-edit.png + /ui-go/shell/08b-edited.png + /ui-go/shell/09-saved.png + /ui-go/shell/10-damaged.png + /ui-go/shell/d01-home.png + /ui-go/shell/d02-reading.png + /ui-go/shell/d02b-page-2.png + /ui-go/shell/d02c-read-mode.png + /ui-go/shell/d02d-read-mode-zoomed.png + /ui-go/shell/d02e-read-mode-left.png + /ui-go/shell/d03-find.png + /ui-go/shell/d04-comment.png + /ui-go/shell/d04b-replied.png + /ui-go/shell/d05-pages-rotated.png + /ui-go/shell/d05b-undone.png + /ui-go/shell/d06-combine.png + /ui-go/shell/d06a-combine-end.png + /ui-go/shell/d06b-combined.png + /ui-go/shell/d07-fill-sign.png + /ui-go/shell/d08-edit.png + /ui-go/shell/d08b-edited.png + /ui-go/shell/d09-saved.png + /ui-go/shell/d10-damaged.png +Traceback (most recent call last): + File "/apps/pdftools/tests/ui.py", line 1331, in + main() + File "/apps/pdftools/tests/ui.py", line 1322, in main + shell_runs(args, runs) + File "/apps/pdftools/tests/ui.py", line 1199, in shell_runs + session("shell", home, light_then_dark) + File "/apps/pdftools/tests/ui.py", line 1186, in session + check_log(log) + File "/apps/pdftools/tests/ui.py", line 1126, in check_log + assert not errors, f"script errors in {log}:\n" + "\n".join(errors) +AssertionError: script errors in /ui-go/shell/shell.log: +[E] splash:36369862144:1174:10 - script time budget exceeded (.sources/makepad/platform/script/src/vm.rs:1230) +exit=1 diff --git a/apps/pdftools/tests/ui.py b/apps/pdftools/tests/ui.py index 378661ca..b8edce60 100644 --- a/apps/pdftools/tests/ui.py +++ b/apps/pdftools/tests/ui.py @@ -12,13 +12,20 @@ shell every mode on the samples in the shell's own window, light, then dark through the shell's own style menu (the dark pass works on - what the light pass left): Home, "Open a PDF from this device" - refused, reading and thumbnails, find, a highlight and its reply, - a rotation and its undo, combine with a page range, initials - placed by Fill & Sign, a text edit, save, a damaged file + what the light pass left): Home and its status line against the + storage's own bytes (files.status), "Open a PDF from this device" + refused, reading and thumbnails, Read mode (entered from the bar, + a page turned and the zoom changed, left by Exit read mode or the + corner control on that page at that zoom), find from the top bar + alone (the left panel given back), a highlight and its reply + dated on this machine's clock, a rotation and its undo, combine + with a page range, initials placed by Fill & Sign, a text edit with + an alignment and a colour, save, a damaged file; then one cover + per PDF in the pdf service's cover cache, each in library.json restart the same home again: the library, the titles, the page a PDF was - left at, and a PDF placed as files.import leaves one - (`Imported PDF.pdf`) + left at, a PDF placed as files.import leaves one (`Imported + PDF.pdf`), every current cover kept, not drawn again, and a PDF + removed from Home taking its cover with it full storage with no room left: the engine's refusal, then a removal empty no PDFs: the empty library and "Open a PDF from this device" (a hidden window never has focus, so the files service refuses the @@ -439,6 +446,44 @@ def range_fields(app): key=lambda w: w["r"][1]) +def open_add_list(app, names=("Board minutes.pdf", "Field guide.pdf", "Apartment lease.pdf")): + """Combine's Add files, tapped until its list of PDFs shows: a tap that + lands while the card is drawn again is lost (seen once in a dark pass), + and a second tap on an open list would close it, so it is tapped again + only while no PDF of the list shows.""" + def shown(): + return any(w["ty"] == "Label" and w.get("t") in names for w in app.widgets()) + for attempt in range(3): + app.tap("Add files", "Label") + try: + wait_until(shown, "the list of PDFs to add did not open", timeout=5) + return + except AssertionError: + if attempt == 2: + raise + + +def range_field_of(app, name, timeout=15.0): + """The page-range field in `name`'s row of the Combine card (the list may + have scrolled the other rows away), once the card shows it: just after + a PDF is added, its name may still be in the list of PDFs to add.""" + found = [] + + def beside(): + # A list scrolled by the wheel may still be moving: the row must sit + # still across two looks before its field is clicked. + first = app.find(name, "Label", timeout=2.0)["r"] + time.sleep(0.4) + label = app.find(name, "Label", timeout=2.0)["r"] + if abs(label[1] - first[1]) > 0.5: + return False + row = label[1] + label[3] / 2 + found[:] = [w["r"] for w in range_fields(app) if abs(w["r"][1] + w["r"][3] / 2 - row) < 40] + return bool(found) + wait_until(beside, f"no page range beside {name!r}", timeout=timeout) + return found[0] + + def press_combine(app): """Combine's own button, at the end of its card (not the mode's tab).""" app.scroll(600) @@ -615,6 +660,181 @@ def fixture_states(app, out, dark): # ---------------------------------------------------------------- shell journey (the real engine) +# The storage of the shell run going on (shell_runs sets it), and what the +# runs saw, written to /run.json for the receipt. +SHELL_JAIL = None +RECEIPT = {} +ALIGNS = ["left", "center", "right", "justify"] + + +def jail_bytes(jail): + """What the app's storage holds, as the shell measures it: every regular file.""" + return sum(f.stat().st_size for f in jail.rglob("*") if f.is_file() and not f.is_symlink()) + + +def storage_shown(app): + """The status line's storage words as (bytes shown, quota in MB), or None.""" + for w in app.widgets(): + m = re.fullmatch(r"([\d.]+)(?: (bytes?|KB))? of (\d+) MB used", (w.get("t") or "").strip()) + if m: + scale = {None: 1 << 20, "KB": 1 << 10}.get(m.group(2), 1) + return float(m.group(1)) * scale, int(m.group(3)) + return None + + +def check_storage_line(app, jail): + """The status line reads files.status: everything in the app's storage + (renders and covers too, not only the PDFs), against its 64 MB.""" + def close(): + shown = storage_shown(app) + used = jail_bytes(jail) + return shown is not None and shown[1] == QUOTA >> 20 and abs(shown[0] - used) <= max(0.12 * (1 << 20), used * 0.05) + wait_until(close, f"the status line {storage_shown(app)} is not the storage's {jail_bytes(jail)} bytes", timeout=30) + library = sum(f.stat().st_size for f in (jail / LIBRARY).glob("*.pdf")) + return {"shown": storage_shown(app), "jail_bytes": jail_bytes(jail), "library_pdf_bytes": library} + + +def check_today(app, moments): + """A comment made at one of `moments` reads "Today HH:MM" on this + machine's clock: the service gives its local time (the engine stamps it + in UTC, which after 17:00 here is already tomorrow).""" + stamps = {time.strftime("Today %H:%M", time.localtime(t)) for t in moments} + wait_until(lambda: any((w.get("t") or "") in stamps for w in app.widgets()), f"no comment dated {sorted(stamps)}") + return sorted(stamps) + + +def align_segment(app, which): + """Tap one of the Edit panel's Alignment segments: the row below its label, + as wide as Apply and Cancel.""" + label = app.find("Alignment", "Label")["r"] + apply_, cancel = app.find("Apply", "Button")["r"], app.find("Cancel", "Button")["r"] + left, right = apply_[0], cancel[0] + cancel[2] + app.click(left + (ALIGNS.index(which) + 0.5) * (right - left) / 4, label[1] + label[3] + 10 + 20) + + +def pick_colour(app, shown, chip, name, grab=None): + """Open the Edit panel's Colour box (showing `shown`) into its row of + colours (grabbed as `grab`, (out, name), when given) and tap number + `chip` (0: the paragraph's own colour, then the six), which the box then + names.""" + box = app.find(shown, "Label")["r"] + left = app.find("Apply", "Button")["r"][0] # the box's left edge: the column's + centre = box[1] + box[3] / 2 + app.click(box[0] + box[2] / 2, centre) + app.gone(shown) + if grab: + app.grab(*grab) + app.click(left + 1 + 4 + chip * 34 + 15, centre) + app.find(name, "Label") + + +def combine_button_in_view(app): + """Combine's own button (the card's, below the mode bar) is in view above + the status line, with no scroll: its rect.""" + ax, ay, aw, ah = app.area() + own = sorted((w for w in app.widgets() if w["ty"] in ("Button", "ButtonFlat") and w.get("t") == "Combine" and w["r"][1] > ay + 53 + 54), + key=lambda w: w["r"][1]) + assert own and own[-1]["r"][1] + own[-1]["r"][3] <= ay + ah - 44 + 1, f"Combine's own button is not in view: {own}" + return own[-1]["r"] + + +def labels(app, text): + """How many visible Labels read exactly `text`.""" + return len([w for w in app.widgets() if w["ty"] == "Label" and w.get("t") == text]) + + +def rail_labels(app): + """The rail's items, top to bottom: the Labels in its column, between the + mode bar (below the 53-point tab row and the 54-point bar) and the + 44-point status line.""" + ax, ay, aw, ah = app.area() + return [w["t"] for w in sorted(app.widgets(), key=lambda w: w["r"][1]) + if w["ty"] == "Label" and w.get("t") and w["r"][0] < ax + 84 + and ay + 53 + 54 <= w["r"][1] and w["r"][1] + w["r"][3] <= ay + ah - 44] + + +def close_results(app, title): + """The search results' own cross: the icon button right of their title.""" + row, (x, y, w, h) = icon_buttons_near(app, title, "Label") + bx, by, bw, bh = [r for r in row if r[0] >= x + w - 1][0] + app.click(bx + bw / 2, by + bh / 2) + + +def pill_end(app): + """The floating bar's last icon button: Read mode's full-screen button.""" + label = next(w for w in app.widgets() if re.fullmatch(r"\d+ / \d+", w.get("t") or "")) + row, _ = icon_buttons_near(app, label["t"], "Label") + bx, by, bw, bh = row[-1] + app.click(bx + bw / 2, by + bh / 2) + + +def zoom_button(app, step): + """The floating bar's zoom out (-1) or in (+1), either side of its zoom.""" + label = next(w for w in app.widgets() if re.fullmatch(r"\d+%", w.get("t") or "")) + row, (x, y, w, h) = icon_buttons_near(app, label["t"], "Label") + if step > 0: + bx, by, bw, bh = [r for r in row if r[0] >= x + w - 1][0] + else: + bx, by, bw, bh = [r for r in row if r[0] + r[2] <= x + 1][-1] + app.click(bx + bw / 2, by + bh / 2) + + +def corner_exit(app): + """Read mode's corner control: the icon button at the app's top right.""" + ax, ay, aw, ah = app.area() + corner = [w["r"] for w in app.widgets() if w["ty"] in ("Button", "ButtonFlat") and not w.get("t") + and w["r"][0] > ax + aw - 90 and w["r"][1] < ay + 90] + assert corner, "no corner control in Read mode" + bx, by, bw, bh = corner[0] + app.click(bx + bw / 2, by + bh / 2) + + +def read_mode(app, out, p, dark): + """Read mode (the user: "there is no full screen read mode?"): entered + from the floating bar's last button, the pages alone; a page turned and + the zoom changed in it; left from the bar's Exit read mode (light) or the + corner control (dark), on that page at that zoom.""" + page = next(w["t"] for w in app.widgets() if re.fullmatch(r"\d+ / \d+", w.get("t") or "")) + pill_end(app) + app.find("Exit read mode", "Button") + app.gone("Search in document") + assert labels(app, "Outline") == 0 and labels(app, "Comments") == 0, "the rail shows in Read mode" + assert not [w for w in app.widgets() if w.get("t") in ("Saved", "Edited")], "the status line shows in Read mode" + app.find(page, "Label") # the same page + app.images(1) + app.grab(out, f"{p}02c-read-mode") + pill_next(app) + n, total = page.split(" / ") + turned = f"{int(n) + 1} / {total}" + app.find(turned, "Label") + before = zoom(app) + zoom_button(app, +1) + wait_until(lambda: zoom(app) > before, "the zoom did not change in Read mode") + zoomed = zoom(app) + app.images(1) + app.grab(out, f"{p}02d-read-mode-zoomed") + if dark: + corner_exit(app) + else: + app.tap("Exit read mode", "Button") + app.find("Search in document", "TextInput") # the bars are back + app.gone("Exit read mode") + app.find(turned, "Label") + assert zoom(app) == zoomed, f"Read mode left at {zoomed}, the document shows {zoom(app)}" + app.images(1) + app.grab(out, f"{p}02e-read-mode-left") + RECEIPT.setdefault("read_mode", []).append({"pass": "dark" if dark else "light", "entered_on": page, "left_on": turned, + "zoom": [before, zoomed], "left_by": "corner control" if dark else "Exit read mode"}) + zoom_button(app, -1) # the zoom the rest of the journey reads at + wait_until(lambda: zoom(app) == before, "the zoom did not go back") + + +def covers_kept(jail): + """The covers in the pdf service's cache: file name -> modification time.""" + folder = jail / ".cache/covers" + return {f.name: f.stat().st_mtime_ns for f in folder.iterdir() if f.is_file()} if folder.is_dir() else {} + + def shell_journey(app, out, dark): """Every mode on the samples, with the real pdf engine, in the shell's own window size. The dark pass runs on what the light pass left: the @@ -625,6 +845,8 @@ def shell_journey(app, out, dark): app.see("Quarterly report.pdf") app.images(3) app.scroll(-3000) + if not dark and SHELL_JAIL is not None: + RECEIPT["storage_line"] = check_storage_line(app, SHELL_JAIL) app.grab(out, f"{p}01-home") if not dark: app.tap("Open a PDF from this device", "Button") @@ -645,14 +867,35 @@ def shell_journey(app, out, dark): app.find("2 / 4", "Label") app.images(2) app.grab(out, f"{p}02b-page-2") + read_mode(app, out, p, dark) + # One search, in the top bar: the rail offers Pages, Outline and Comments. + assert rail_labels(app) == ["Pages", "Outline", "Comments"], f"the rail: {rail_labels(app)}" + # The left side the search gives back when it ends: the Comments panel + # (light), or the left side folded away (dark). + if dark: + app.tap("Pages", "Label") # the rail's Pages, open: folds it + wait_until(lambda: labels(app, "Pages") == 1, "the Pages panel did not fold") + else: + app.tap("Comments", "Label") + wait_until(lambda: labels(app, "Comments") == 2, "the Comments panel did not open") app.tap("Search in document", "TextInput") app.type("revenue") app.key("Return") app.find("9 matches on 4 pages", "Label", timeout=60) app.images(1) app.grab(out, f"{p}03-find") - app.tap("Done") + if dark: + close_results(app, "9 matches on 4 pages") # the results' own cross ends the search too + app.gone("9 matches on 4 pages") + wait_until(lambda: labels(app, "Pages") == 1 and labels(app, "Comments") == 1, "the left side did not fold again") + else: + app.tap("Done") + app.gone("9 matches on 4 pages") + wait_until(lambda: labels(app, "Comments") == 2, "Done did not give the Comments panel back") + app.grab(out, f"{p}03b-find-done") + app.tap("Pages", "Label") # the Pages panel again, as the rest of the journey had it + wait_until(lambda: labels(app, "Pages") == 2, "the Pages panel did not open") app.tap("Comment", "Button") name_once(app) @@ -661,9 +904,12 @@ def shell_journey(app, out, dark): app.find("2 / 4", "Label") app.images(1) before = comment_count(app) + made = time.time() click_page(app, 120, 128) # the Summary's first line wait_until(lambda: comment_count(app) == before + 1, "the highlight never joined the comments") app.find("Maya Chen", "Label") + RECEIPT.setdefault("comment_dates", []).append({"pass": "dark" if dark else "light", "utc_now": time.strftime("%Y-%m-%dT%H:%MZ", time.gmtime()), + "shown_one_of": check_today(app, (made, time.time()))}) app.grab(out, f"{p}04-comment") app.tap("Reply...", "TextInput") app.type("Checked against the ledger.") @@ -689,12 +935,18 @@ def shell_journey(app, out, dark): app.grab(out, f"{p}05b-undone") app.tap("Combine", "Button") - app.tap("Add files", "Label") + open_add_list(app) + app.reveal("Board minutes.pdf") # the list may scroll inside the card app.tap("Board minutes.pdf", "Label") - x, y, w, h = range_fields(app)[1]["r"] + app.reveal("Board minutes.pdf") # its row now + x, y, w, h = range_field_of(app, "Board minutes.pdf") app.click(x + w / 2, y + h / 2) app.type("1") app.find("(1 page)", "Label") + # The card's footer stays in view however tall its list (design 06 when + # it fits; the list scrolls inside the card when it doesn't). + app.find("One PDF of 5 pages", "Label") + RECEIPT.setdefault("combine_button", []).append({"pass": "dark" if dark else "light", "area": app.area(), "button": combine_button_in_view(app)}) app.grab(out, f"{p}06-combine") app.scroll(600) # the card's end: the total, the name, Combine app.find("One PDF of 5 pages", "Label") @@ -726,6 +978,11 @@ def shell_journey(app, out, dark): app.find("Click a paragraph on the page to edit its text.", "Label") click_page(app, 120, 168) # clause 1 app.find("Paragraph", "Label", exact=False) + # Design 08's Alignment and Colour: centred and red, then (the dark pass, + # on what the light one left) flush right in the paragraph's own colour. + align_segment(app, "right" if dark else "center") + if not dark: + pick_colour(app, "Its own colour", 4, "Red", grab=(out, "08a-colours")) editor = [w for w in app.widgets() if w["ty"] == "TextInput" and (w.get("t") or "").startswith("This agreement")][0]["r"] app.click(editor[0] + editor[2] - 6, editor[1] + editor[3] - 7) # after its last word app.type(" (amended)") @@ -786,11 +1043,38 @@ def restart(app, out): app.find("2 / 4", "Label", timeout=60) # where the shell run left it app.images(1) app.grab(out, "r03-place-kept") + # Remove deletes the PDF's kept cover with it. + app.tap("Open", "Button") + name = "Quarterly report combined.pdf" + index = json.loads((SHELL_JAIL / "accounts/device/library.json").read_text())["docs"] + cover = index.get(name, {}).get("cover", "") + assert cover.startswith(".cache/covers/") and (SHELL_JAIL / cover).is_file(), f"{name} has no kept cover: {index.get(name)}" + remove_card(app, name) + wait_until(lambda: not (SHELL_JAIL / cover).exists(), "Remove left the PDF's cover behind") + assert not (SHELL_JAIL / LIBRARY / name).exists(), "Remove left the PDF behind" + app.grab(out, "r04-removed") + RECEIPT["removed_with_its_cover"] = {"pdf": name, "cover": cover} + + +def remove_card(app, name): + """Remove `name` from Home with its card's trash button, and confirm.""" + app.reveal(name) + lx, ly, lw, lh = app.find(name, "Label")["r"] + trash = [w["r"] for w in app.widgets() if w["ty"] in ("Button", "ButtonFlat") and not w.get("t") and w["r"][2] < 30 + and lx - 10 <= w["r"][0] <= lx + 300 and ly <= w["r"][1] <= ly + 90] + assert trash, f"no remove button on {name}'s card" + bx, by, bw, bh = sorted(trash, key=lambda r: r[1])[0] + app.click(bx + bw / 2, by + bh / 2) + app.find("Remove it from PDF Tools' storage?", "Label") + app.tap("Remove", "Button") + app.find("from PDF Tools.", "Label", exact=False, timeout=20) def full(app, out): """No room left: the engine refuses to write, and the app says so.""" app.find("PDF Tools' storage is full", "Label", timeout=90) + # No room for a cover: each card still shows its pages and size (pdf.info). + wait_until(lambda: not any((w.get("t") or "") == "Reading…" for w in app.widgets()), "a card still says Reading… with the storage full", timeout=90) app.grab(out, "f01-home-full") app.scroll(400) time.sleep(1) @@ -922,15 +1206,37 @@ def session(name, home, steps): if "shell" in runs or "restart" in runs: home = scratch / "home" fixture(home / "apps") + global SHELL_JAIL + SHELL_JAIL = home / "apps" / APP def light_then_dark(app, out): shell_journey(app, out, dark=False) app.style("octosense-dark", "octosense dark") shell_journey(app, out, dark=True) session("shell", home, light_then_dark) + # Home drew each PDF's cover once (pdf.cover), and a saved PDF's + # older cover went: one cover per PDF, each named in library.json. + kept = covers_kept(SHELL_JAIL) + prefixes = [name.split("-")[0] for name in kept] + assert kept and len(prefixes) == len(set(prefixes)), f"covers: {sorted(kept)}" + index = json.loads((SHELL_JAIL / "accounts/device/library.json").read_text())["docs"] + named = {e["cover"] for e in index.values() if e.get("cover")} + assert named and all(c.startswith(".cache/covers/") and c[len(".cache/covers/"):] in kept for c in named), f"library.json covers: {named}" + RECEIPT["covers_after_shell_run"] = sorted(kept) if "restart" in runs: fixture("--import-sample", home / "apps" / APP / LIBRARY / "Imported PDF.pdf") session("restart", home, restart) + # The restart drew no current cover again: same files, same + # times. (A PDF saved after Home last drew its cover has none + # in library.json, and is drawn again.) + removed = RECEIPT.get("removed_with_its_cover", {}).get("cover", "") + current = {name: at for name, at in kept.items() if ".cache/covers/" + name in named and ".cache/covers/" + name != removed} + again = covers_kept(SHELL_JAIL) + redrawn = [name for name, at in current.items() if again.get(name) != at] + assert current and not redrawn, f"covers drawn again after the restart: {redrawn}" + RECEIPT["covers_after_restart"] = {"kept_untouched": sorted(current), "drawn_now": sorted(set(again) - set(kept)), + "gone_now": sorted(set(kept) - set(again))} + (args.output / "run.json").write_text(json.dumps(RECEIPT, indent=1)) if "full" in runs: home = scratch / "full" fixture(home / "apps") diff --git a/crates/shell/src/files_service/README.md b/crates/shell/src/files_service/README.md index ccd99ff2..6ad167b8 100644 --- a/crates/shell/src/files_service/README.md +++ b/crates/shell/src/files_service/README.md @@ -10,7 +10,7 @@ count, never a host path or Android provider URI. No separate blob store is crea | Method | Arguments | Result | | --- | --- | --- | -| `files.status` | `{}` | `import_supported`, `export_supported`, `photo_pick_supported`, `text_share_supported`, `storage_granted`, `max_file_bytes`, `max_import_bytes`, `max_share_text_bytes`, `foreground_required` | +| `files.status` | `{}` | `import_supported`, `export_supported`, `photo_pick_supported`, `text_share_supported`, `storage_granted`, `max_file_bytes`, `max_import_bytes`, `max_share_text_bytes`, `foreground_required`; with live storage, `used_bytes` and `quota_bytes` | | `files.import` | `{"path":"/documents/report.pdf"}` | `{"cancelled":false,"path":"/documents/report.pdf","bytes":123,"name":"Q3 report.pdf"}` | | `files.pick_photo` | `{"path":"/photos/new.png"}` | Choose one PNG/JPEG/WebP; returns the import fields plus its signature-detected `mime` | | `files.share` | `{"text":"Good morning 🌅"}` | Android only: `{"handoff":"chooser_opened","delivery":"unknown"}` after native chooser dispatch | @@ -33,6 +33,17 @@ reason to automatically open another chooser. Closing the app cannot recall an O chooser that has already opened. The native result uses a unique per-request correlation value and a bounded reply; stale replies are discarded. +With live app storage, `files.status` also says how much the app's storage +holds and may hold, so an app can show "14.6 of 64 MB used" without counting +its own files. `used_bytes` is the host's measure of the app's jail, the root +App Hub gives the app's isolates (`app_storage::Storage::usage`, the measure +the engines' room checks keep to): every regular file under it, links never +followed. `quota_bytes` is the calling isolate's storage quota, the one its +own writes and imports are checked against. Both are left out when the +isolate has no live storage or the host keeps no app storage. They are read +when asked, never pushed: ask again after a change. Status does not open a +dialog or need the foreground. + `name` is the chosen document's display name, for the app to show: the file name without folders, control characters or invisible direction marks, at most 128 bytes. The app still decides where the copy is stored (`path`). It is absent when @@ -112,6 +123,12 @@ Existing unrelated compiler warnings remain. Interactive dialogs and Android provider/device behavior remain **unverified**. All 16 combined Android Java templates compiled with 23 existing deprecation warnings. +Storage use in `files.status` (10 Oct 2026): `files_service::tests::status_reports_the_storage_used_and_its_quota` +(a live isolate on the host's app storage, in a child process: the jail's bytes, a write showing +on the next status, the isolate's quota) and `status_without_storage_reports_no_use_or_quota` +passed with `cargo test --locked --features mobile-apps -p octosense-shell --lib files_service` +from `phone/` on macOS. + Photo/share validation is tracked separately from the older transfer checks above. Source tests cover actual signatures, traversal, explicit text limits, rejected attachment/recipient fields and handoff wording. A compiler check is not a real diff --git a/crates/shell/src/files_service/README.zh-CN.md b/crates/shell/src/files_service/README.zh-CN.md index d70194d9..7b5c70c5 100644 --- a/crates/shell/src/files_service/README.zh-CN.md +++ b/crates/shell/src/files_service/README.zh-CN.md @@ -9,10 +9,18 @@ Splash 文件系统；导出会保存已有应用文件的快照。应用只收 | 方法 | 参数 | 返回值 | | --- | --- | --- | -| `files.status` | `{}` | `import_supported`、`export_supported`、`storage_granted`、`max_file_bytes`、`max_import_bytes`、`foreground_required` | +| `files.status` | `{}` | `import_supported`、`export_supported`、`photo_pick_supported`、`text_share_supported`、`storage_granted`、`max_file_bytes`、`max_import_bytes`、`max_share_text_bytes`、`foreground_required`；有可用存储时另有 `used_bytes`、`quota_bytes` | | `files.import` | `{"path":"/documents/report.pdf"}` | `{"cancelled":false,"path":"/documents/report.pdf","bytes":123,"name":"Q3 report.pdf"}` | | `files.export` | `{"path":"/documents/report.pdf","name":"Report.pdf"}` | 相同的成功字段；可选的 `name` 是建议给系统对话框的文件名，不含目录 | +有可用的应用存储时，`files.status` 还会说明应用存储已用多少、最多可用多少，应用无需 +自行统计文件即可显示“已用 14.6 MB，共 64 MB”。`used_bytes` 是宿主对应用 jail 的测量 +值，即 App Hub 交给该应用各隔离实例的存储根（`app_storage::Storage::usage`，与引擎 +检查剩余空间时用的是同一种测量）：统计其下全部普通文件，从不跟随符号链接。 +`quota_bytes` 是调用方隔离实例的存储配额，即该应用自身写入和导入时检查的配额。 +调用方隔离实例没有可用存储、或宿主不保存应用存储时，两者都不返回。两者在查询时 +读取，不会主动推送：发生变化后请再次查询。状态查询不会打开对话框，也不要求前台。 + `name` 是所选文档的显示名称，供应用展示：去掉文件夹、控制字符和不可见的方向标记后的 文件名，最多 128 字节。副本仍存放在应用指定的 `path`。清理后为空时不返回；Android 的 文档加载器暂不查询显示名称，因此 Android 上也不返回。 @@ -75,6 +83,12 @@ JNI 传输使用分配检查和有界复制，将 Java 异常转为错误并清 Android Java 模板已编译通过，有 23 条已有的弃用警告。 +`files.status` 的存储用量（2026 年 10 月 10 日）：在 macOS 上于 `phone/` 目录运行 +`cargo test --locked --features mobile-apps -p octosense-shell --lib files_service`， +`files_service::tests::status_reports_the_storage_used_and_its_quota`（在子进程中使用宿主应用存储上的 +存活隔离实例：jail 字节数、写入后下一次查询即反映、该实例的配额）与 +`status_without_storage_reports_no_use_or_quota` 均已通过。 + ## 图片选择与文本分享 `files.status` 还返回 `photo_pick_supported`、`text_share_supported` 和 diff --git a/crates/shell/src/files_service/mod.rs b/crates/shell/src/files_service/mod.rs index 6e57c088..fb5c6320 100644 --- a/crates/shell/src/files_service/mod.rs +++ b/crates/shell/src/files_service/mod.rs @@ -228,6 +228,35 @@ fn parse_operation(method: &str, args: &Value) -> Result { Ok(Operation::Export { path, name }) } +/// `files.status` for the calling isolate. `storage` is its live storage +/// scope, `jail_bytes` measures what its jail holds now. With storage, it +/// also says how much the storage holds and may hold: `used_bytes`, as the +/// shell measures the jail (the measure the engines' room checks keep to), +/// and `quota_bytes`, the live scope's quota that the app's own writes are +/// checked against. Both are left out when either is unknown. +fn status_answer(storage: Option<&StorageAccess>, jail_bytes: impl FnOnce() -> Option) -> Value { + let mut answer = json!({ + "import_supported":file_dialogs::native_file_bytes_supported(), + "export_supported":file_dialogs::native_file_bytes_supported(), + "max_file_bytes":MAX_FILE_BYTES, "max_import_bytes":MAX_IMPORT, "foreground_required":true, + "photo_pick_supported":file_dialogs::native_file_bytes_supported(), + "text_share_supported":cfg!(target_os="android"), "max_share_text_bytes":MAX_SHARE_TEXT, + "storage_granted":storage.is_some() + }); + if let Some((storage, used)) = storage.and_then(|storage| Some((storage, jail_bytes()?))) { + answer["used_bytes"] = used.into(); + answer["quota_bytes"] = storage.quota().into(); + } + answer +} + +/// What `app`'s jail holds now, as the host's app storage measures it +/// (ADR 0004 §11: the sandbox cannot count bytes, so the host does). The +/// jail is the root App Hub gives the app's isolates: `/`. +fn jail_bytes(app: &str) -> Option { + crate::app_storage::host()?.usage(app).ok().map(|usage| usage.jail_bytes) +} + fn admission(app: &str, host: &std::path::Path) -> Result { let loaded = crate::host_tools::script_apps::admitted_host(app, host) .map_err(|_| "permission_denied: App is no longer admitted")?; @@ -299,7 +328,7 @@ impl HostService for FilesService { let mut methods = vec![HostApiMethod::new("files.status", 1, "files", "Discover file transfer support without opening a dialog", json!({"type":"object","additionalProperties":false}), json!({"type":"object","required":["import_supported","export_supported","max_file_bytes","max_import_bytes","storage_granted","foreground_required"], - "properties":{"import_supported":{"type":"boolean"},"export_supported":{"type":"boolean"},"max_file_bytes":{"type":"integer"},"max_import_bytes":{"type":"integer"},"photo_pick_supported":{"type":"boolean"},"text_share_supported":{"type":"boolean"},"max_share_text_bytes":{"type":"integer"},"storage_granted":{"type":"boolean"},"foreground_required":{"const":true}}})) + "properties":{"import_supported":{"type":"boolean"},"export_supported":{"type":"boolean"},"max_file_bytes":{"type":"integer"},"max_import_bytes":{"type":"integer"},"photo_pick_supported":{"type":"boolean"},"text_share_supported":{"type":"boolean"},"max_share_text_bytes":{"type":"integer"},"storage_granted":{"type":"boolean"},"used_bytes":{"type":"integer","minimum":0},"quota_bytes":{"type":"integer","minimum":0},"foreground_required":{"const":true}}})) .with_platforms(&["macos","windows","linux","android","ios","openharmony","web"]).with_agent_access(AgentAccess::Allowed)]; if cfg!(target_os = "android") { methods.push(HostApiMethod::new("files.share", 1, "files", "Open Android's text share chooser; OS handoff does not confirm delivery", @@ -344,14 +373,8 @@ impl HostService for FilesService { // Status is intentionally nonprompting and does not need storage. let heap = reply.isolate_key(); reply.send(admission(&call.app_id, &call.host_dir).map(|_| { - json!({ - "import_supported":file_dialogs::native_file_bytes_supported(), - "export_supported":file_dialogs::native_file_bytes_supported(), - "max_file_bytes":MAX_FILE_BYTES, "max_import_bytes":MAX_IMPORT, "foreground_required":true, - "photo_pick_supported":file_dialogs::native_file_bytes_supported(), - "text_share_supported":cfg!(target_os="android"), "max_share_text_bytes":MAX_SHARE_TEXT, - "storage_granted":splash_storage::storage_for_heap(heap, &call.app_id).is_some() - }) + let storage = splash_storage::storage_for_heap(heap, &call.app_id); + status_answer(storage.as_ref(), || jail_bytes(&call.app_id)) })); return; } diff --git a/crates/shell/src/files_service/tests.rs b/crates/shell/src/files_service/tests.rs index b7428794..a076389f 100644 --- a/crates/shell/src/files_service/tests.rs +++ b/crates/shell/src/files_service/tests.rs @@ -386,6 +386,114 @@ fn a_selected_document_is_staged_off_the_ui_thread_and_linked_in_against_the_liv let _ = std::fs::remove_dir_all(root); } +/// Without live storage, `files.status` says nothing of the storage's use +/// and does not measure a jail. +#[test] +fn status_without_storage_reports_no_use_or_quota() { + let answer = status_answer(None, || panic!("no jail is measured without live storage")); + assert_eq!(answer["storage_granted"], false); + assert!(answer.get("used_bytes").is_none() && answer.get("quota_bytes").is_none(), "{answer}"); + assert_eq!(answer["max_import_bytes"], MAX_IMPORT); + let schema = &FilesService.api_methods()[0].output_schema; + for key in ["used_bytes", "quota_bytes"] { + assert_eq!(schema["properties"][key]["type"], "integer", "discovery declares {key}"); + } +} + +/// `files.status` says how much the calling app's storage holds and may +/// hold: `used_bytes`, as the host's app storage measures the app's jail +/// (the root App Hub gives its isolates), and `quota_bytes`, the live +/// storage scope's quota; a write shows on the next status. A child +/// process owns the global registries and the host's app storage, in a +/// home of its own. +#[test] +fn status_reports_the_storage_used_and_its_quota() { + const CHILD: &str = "OCTOSENSE_FILES_STATUS_TEST_CHILD"; + if std::env::var_os(CHILD).is_none() { + let home = std::env::temp_dir().join(format!("files-status-{}", uuid::Uuid::new_v4())); + std::fs::create_dir_all(&home).unwrap(); + let output = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", "files_service::tests::status_reports_the_storage_used_and_its_quota", "--nocapture"]) + .env(CHILD, &home) + // Nothing outside this home: no legacy app homes to adopt. + .env("OCTOSENSE_HOME", home.join("home")) + .env_remove("OCTOSENSE_APP_DATA") + .output() + .unwrap(); + let _ = std::fs::remove_dir_all(&home); + assert!(output.status.success(), "{}\n{}", String::from_utf8_lossy(&output.stdout), String::from_utf8_lossy(&output.stderr)); + return; + } + use makepad_widgets::*; + const APP: &str = "os.filesstatus"; + let root = std::path::PathBuf::from(std::env::var_os(CHILD).unwrap()); + let storage = crate::app_storage::init(Some(root.clone())).expect("the host's app storage"); + let apps = storage.layout().apps_root().to_path_buf(); + octosense_appstore::set_data_root(apps.clone()); + let dir = crate::host_tools::script_apps::tests::stamped_bundle("camera", APP, |dir, manifest| { + manifest["id"] = json!(APP); + manifest["capabilities"] = json!([]); + manifest["requires"] = json!(["host-api-v1"]); + manifest["storage"] = json!({"max_bytes": 8 << 20}); + manifest.as_object_mut().unwrap().remove("agent"); + for path in ["tools.json", "AGENT.md"] { + let _ = std::fs::remove_file(dir.join(path)); + } + std::fs::write(dir.join("main.splash"), "use mod.widgets.*\nApp { Label {text: \"Status test\"} }\n").unwrap(); + }); + let packed = octosense_app_hub::pack::pack_system_app(&dir).unwrap(); + std::fs::remove_dir_all(dir).unwrap(); + octosense_appstore::system::register_system_app(octosense_appstore::system::SystemApp { + id: APP, + name: "Status test", + pack: Box::leak(packed.pack_json.into_boxed_str()), + assets: &[], + }); + + // The app's jail holds 3,002 bytes; its isolate is rooted there with an + // 8 MiB quota, as App Hub seats it. + let jail = storage.layout().app(APP).unwrap().jail; + std::fs::create_dir_all(jail.join("library")).unwrap(); + std::fs::write(jail.join("library/a.pdf"), vec![1u8; 3_000]).unwrap(); + std::fs::write(jail.join("notes.json"), b"{}").unwrap(); + let mut cx = Cx::new(Box::new(|_, _| {})); + let mut card = cx.with_vm(|vm| { + makepad_widgets::script_mod(vm); + let value = vm.eval(script! {use mod.widgets.* Splash{}}); + Splash::script_from_value(vm, value) + }); + card.set_policy(&mut cx, Some(vec![]), None); + card.set_host_tag(&mut cx, Some(APP.into())); + card.set_sandbox_dir(&mut cx, Some(jail.clone())); + card.set_storage_quota(&mut cx, Some(8 << 20)); + card.set_text(&mut cx, "View {}"); + let heap = card.isolate_heap_key(&mut cx).unwrap(); + + struct NoSheet; + impl ServiceHost for NoSheet { + fn open_sheet(&mut self, _: String) { + panic!("status opened a sheet"); + } + fn close_sheet(&mut self) {} + } + register(); + let status = |request: u64| -> serde_json::Value { + let call = ServiceCall { app_id: APP.into(), service: "files.status".into(), args: json!({}), from_sheet: false, may_prompt: false, host_dir: apps.join(".host") }; + services::dispatch(call, heap, request, &mut NoSheet); + let (_, _, result) = services::take_replies_for(&[heap]).pop().expect("status answers at once"); + serde_json::from_str(&result.expect("status answers")).unwrap() + }; + let first = status(1); + assert_eq!((first["storage_granted"].clone(), first["used_bytes"].clone(), first["quota_bytes"].clone()), (json!(true), json!(3_002), json!(8 << 20)), "{first}"); + std::fs::write(jail.join("library/b.pdf"), vec![2u8; 1_000]).unwrap(); + assert_eq!(status(2)["used_bytes"], 4_002, "a write shows on the next status"); + // A live scope whose jail cannot be measured says neither. + let live = splash_storage::storage_for_heap(heap, APP).expect("live storage"); + let unmeasured = status_answer(Some(&live), || None); + assert_eq!(unmeasured["storage_granted"], true); + assert!(unmeasured.get("used_bytes").is_none() && unmeasured.get("quota_bytes").is_none(), "{unmeasured}"); +} + #[test] fn queued_foreground_authority_expires_before_launch_but_not_chooser_completion() { use makepad_widgets::WindowId; diff --git a/crates/shell/src/pdftools_model_tests.rs b/crates/shell/src/pdftools_model_tests.rs index babbaa5c..2a146037 100644 --- a/crates/shell/src/pdftools_model_tests.rs +++ b/crates/shell/src/pdftools_model_tests.rs @@ -163,3 +163,159 @@ fn the_shipped_manifest_asks_for_the_designs_window_size() { assert_eq!(manifest.schema_minor, 1); assert_eq!(manifest.window, Some(octosense_app_contract::WindowHint::new(1536, 1024))); } + +#[test] +fn the_storage_line_reads_what_files_status_says() { + // Design 08's status line, from files.status's used_bytes and quota_bytes. + assert_eq!(pdftools_model("used_text(15309209, 67108864).to_json()"), json!("14.6 of 64 MB used")); + assert_eq!(pdftools_model("used_text(92160, 67108864).to_json()"), json!("90 KB of 64 MB used")); + assert_eq!(pdftools_model("used_text(4002, 8388608).to_json()"), json!("4 KB of 8 MB used")); + assert_eq!( + pdftools_model("usage_from({used_bytes: 15309209 quota_bytes: 67108864}).to_json()"), + json!({"used": 15309209, "quota": 67108864}) + ); + // No storage, or a shell from before files.status said: nothing to read. + for data in ["{}", "nil", "{used_bytes: 5}", "{used_bytes: 5 quota_bytes: 0}"] { + assert_eq!(pdftools_model(&format!("usage_from({data}).to_json()")), json!(null), "{data}"); + } +} + +#[test] +fn the_edit_panel_reads_a_paragraphs_alignment_from_its_lines() { + let align = |boxes: &str| pdftools_model(&format!("guess_align({boxes}).to_json()")); + // Design 08's paragraph: flush left, ragged right. + assert_eq!(align("[[56, 100, 300, 14], [56, 116, 280, 14], [56, 132, 120, 14]]"), json!("left")); + assert_eq!(align("[[56, 100, 300, 14], [56, 116, 300, 14], [56, 132, 120, 14]]"), json!("justify")); + assert_eq!(align("[[56, 100, 300, 14], [56, 116, 300.8, 14]]"), json!("left"), "two lines may just happen to end together"); + assert_eq!(align("[[106, 100, 200, 14], [126, 116, 160, 14], [156, 132, 100, 14]]"), json!("center")); + assert_eq!(align("[[100, 100, 256, 14], [150, 116, 206, 14]]"), json!("right")); + assert_eq!(align("[[70, 100, 286, 14], [56, 116, 290, 14], [56, 132, 120, 14]]"), json!("left"), "an indented first line"); + assert_eq!(align("[[56, 100, 300, 14]]"), json!("left"), "one line shows nothing"); + assert_eq!(align("[]"), json!("left")); +} + +#[test] +fn an_edit_sends_its_text_and_alignment_and_a_chosen_colour() { + // SERVICE.md "Edit": the engine sets a paragraph flush left unless told, + // so the alignment always goes; the colour only once one is chosen. + let edit = |draft: &str, align: &str, color: &str| { + format!("{{page: 2 n: 3 text: \"Old\" draft: \"{draft}\" align: \"{align}\" align0: \"left\" color: {color}}}") + }; + assert_eq!( + pdftools_model(&format!("edit_args(\"d1\", {}).to_json()", edit("New", "center", "nil"))), + json!({"doc": "d1", "page": 2, "paragraph": 3, "text": "New", "align": "center"}) + ); + assert_eq!( + pdftools_model(&format!("edit_args(\"d1\", {}).to_json()", edit("Old", "left", "\"#c01c28\""))), + json!({"doc": "d1", "page": 2, "paragraph": 3, "text": "Old", "align": "left", "color": "#c01c28"}) + ); + let changes = |e: String| pdftools_model(&format!("edit_changes({e}).to_json()")); + assert_eq!(changes(edit("Old", "left", "nil")), json!(false), "nothing to apply"); + assert_eq!(changes(edit("New", "left", "nil")), json!(true)); + assert_eq!(changes(edit("Old", "right", "nil")), json!(true), "an alignment alone"); + assert_eq!(changes(edit("Old", "left", "\"#000000\"")), json!(true), "a colour alone"); + assert_eq!(pdftools_model("colour_name(nil).to_json()"), json!("Its own colour")); + assert_eq!(pdftools_model("colour_name(\"#c01c28\").to_json()"), json!("Red")); + // What the panel offers is what pdf.edit_text takes. + assert_eq!(pdftools_model("ALIGNS.to_json()"), json!(["left", "center", "right", "justify"])); + for c in pdftools_model("TEXT_COLOURS.to_json()").as_array().unwrap() { + let hex = c["hex"].as_str().unwrap(); + assert!(hex.len() == 7 && hex.starts_with('#') && hex[1..].bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)), "{c}"); + } +} + +#[test] +fn the_combine_card_scrolls_its_list_only_when_the_window_is_too_short() { + // Each PDF's row and line (114), Add files (60), the box's border (2); + // the list of PDFs to add while it is open (10, and 40 a row). + let list = |items: u32, adding: u32| pdftools_model(&format!("combine_list_h({items}, {adding}).to_json()")); + assert_eq!(list(2, 0), json!(290)); + assert_eq!(list(1, 5), json!(386)); + let fits = |list_h: u32, height: u32, error: bool| pdftools_model(&format!("combine_fits({list_h}, {height}, {error}).to_json()")); + // Design 06's size (1536 x 1024): two PDFs and the card's own button fit + // as designed. + assert_eq!(fits(290, 1024, false), json!(true)); + // The desktop's window above the dock (1292 x 662) and its default + // (990 x 603): the list scrolls inside the card, its footer in view. + assert_eq!(fits(290, 662, false), json!(false)); + assert_eq!(fits(290, 603, false), json!(false)); + // Where it starts to fit: the bars (151), the card's margins (82) and the + // rest of the card (279), and a refusal's line (30) takes room. + assert_eq!(fits(290, 802, false), json!(true)); + assert_eq!(fits(290, 801, false), json!(false)); + assert_eq!(fits(290, 802, true), json!(false)); +} + +#[test] +fn search_is_the_top_bars_and_the_rail_offers_pages_outline_and_comments() { + // The user: "side search and top search are duplicated". Search in + // document is the one way to search; the rail has no Search of its own. + let rail = pdftools_model("RAIL.to_json()"); + let ids: Vec<&str> = rail.as_array().unwrap().iter().map(|r| r["id"].as_str().unwrap()).collect(); + assert_eq!(ids, ["pages", "outline", "comments"]); + let labels: Vec<&str> = rail.as_array().unwrap().iter().map(|r| r["label"].as_str().unwrap()).collect(); + assert_eq!(labels, ["Pages", "Outline", "Comments"]); + // While the left panel shows search results, no rail item is lit. + let lit = |id: &str, mode: &str, panel: &str, open: bool| pdftools_model(&format!("rail_lit(\"{id}\", \"{mode}\", \"{panel}\", {open}).to_json()")); + for id in ids { + assert_eq!(lit(id, "read", "search", true), json!(false), "{id} while results show"); + assert_eq!(lit(id, "read", id, true), json!(true), "{id} while its own panel shows"); + assert_eq!(lit(id, "read", id, false), json!(false), "{id} while the left side is folded"); + } + assert_eq!(lit("pages", "pages", "search", false), json!(true), "the Pages mode lights Pages"); + assert_eq!(lit("comments", "pages", "comments", true), json!(false)); +} + +#[test] +fn a_search_gives_the_left_side_back_when_it_ends() { + let back = |from: &str| pdftools_model(&format!("panel_after_find({from}).to_json()")); + // What the left side showed before the results took it. + assert_eq!(back("\"outline\""), json!("outline")); + assert_eq!(back("\"comments\""), json!("comments")); + assert_eq!(back("\"pages\""), json!("pages")); + assert_eq!(back("\"\""), json!(""), "folded away before, folded away after"); + // Unknown: Pages. + assert_eq!(back("nil"), json!("pages")); + assert_eq!(back("\"search\""), json!("pages")); +} + +#[test] +fn read_mode_shows_the_pages_alone() { + // The user: "there is no full screen read mode?". In Read mode only the + // pages, the floating bar and the corner control that leaves it show. + assert_eq!( + pdftools_model("chrome_for(true).to_json()"), + json!({"tabs": false, "modebar": false, "rail": false, "panels": false, "right": false, "toolrow": false, "status": false, "exit": true}) + ); + assert_eq!( + pdftools_model("chrome_for(false).to_json()"), + json!({"tabs": true, "modebar": true, "rail": true, "panels": true, "right": true, "toolrow": true, "status": true, "exit": false}) + ); + // The canvas: the window less the rail (84 and its line), the panels and + // the bars (tab row 53, mode bar 54, status line 44, two lines); in Read + // mode, the whole window. + let canvas = |w: u32, h: u32, reading: bool, left: u32, right: u32| { + pdftools_model(&format!("canvas_size({w}, {h}, {reading}, {left}, {right}).to_json()")) + }; + assert_eq!(canvas(1292, 662, false, 205, 0), json!([1002, 509]), "the window's own size, Pages open"); + assert_eq!(canvas(1292, 662, true, 205, 425), json!([1292, 662]), "Read mode: the panels' room is the pages'"); + assert_eq!(canvas(990, 603, false, 205, 321), json!([379, 450])); + assert_eq!(canvas(300, 200, false, 205, 321), json!([240, 240]), "never smaller than 240"); +} + +#[test] +fn read_mode_keeps_the_zoom_the_person_chose() { + // Entering or leaving Read mode: a chosen zoom stays, a fit fits the new + // canvas, the automatic zoom is worked out again. (The script's numbers + // are single precision: compared to a ten-thousandth.) + let kept = |zoom: f64, auto: bool, fit: &str, fit_w: f64, fit_p: f64, start: f64| { + pdftools_model(&format!("kept_zoom({zoom}, {auto}, \"{fit}\", {fit_w}, {fit_p}, {start}).to_json()")).as_f64().unwrap() + }; + let near = |got: f64, want: f64, what: &str| assert!((got - want).abs() < 1e-4, "{what}: {got} for {want}"); + near(kept(1.25, false, "", 2.0907, 0.6766, 1.0), 1.25, "the zoom the person chose"); + near(kept(0.8, true, "", 2.0907, 0.6766, 1.0), 1.0, "the automatic zoom, worked out again"); + near(kept(1.6, false, "width", 2.0907, 0.6766, 1.0), 2.09, "fit width, on the new canvas"); + near(kept(1.6, false, "page", 2.0907, 0.6766, 1.0), 0.67, "fit page, on the new canvas"); + near(kept(1.0, false, "width", 5.5, 0.1, 1.0), 4.0, "at most 400%"); + near(kept(1.0, false, "page", 5.5, 0.1, 1.0), 0.25, "at least 25%"); +} diff --git a/docs/host-os-api-status.md b/docs/host-os-api-status.md index bb1e609b..f175cb90 100644 --- a/docs/host-os-api-status.md +++ b/docs/host-os-api-status.md @@ -18,7 +18,7 @@ This page describes the **OS and public API integration** in [Desktop RC2](https | Standalone audio | `microphone.record_start/record_status/record_stop/record_cancel@1` and `audio.play/status/stop@1` provide short, foreground-only, app-isolate-owned sessions using app storage. Recording requires the app and OS microphone grants. | macOS/Android source implementations. Real recording and playback acceptance is pending; these APIs do not add ASR/TTS or background streaming. See [audio sessions](../crates/shell/src/audio_service/README.md). | | Video widget controls | `video.playback_controls@1` advertises the Splash `Video` widget ABI: preparation, playback, pause/resume, seek, volume/rate and state/error inspection. It is **not callable through `host.request`**. | Native macOS playback passed 16 checks; OnePlus 6 / Android 15 passed 20 callback/decoder checks. The [separate fixture](../tools/fixtures/video-api-lab/README.md) uses only a synthetic local MP4; other codecs/backends remain unverified. | -File transfers keep the whole-jail quota and 256-entry bounds. `files.import` takes a document of up to 64 MiB (16 MiB on Android, `max_import_bytes`): a worker stages it beside the jail and the UI links it in between script turns, so its bytes never pass through the script heap. Photo picks and exports keep the 1 MiB per-file bound. Import refuses overwrite and checks ownership, traversal and symlinks. Dialogs and callbacks retain the authenticated app/isolate identity; grants and lifetime are checked again on completion. Closing an app invalidates pending work, but cannot roll back an export whose native write has already started. Android document picks do not retain persistent URI grants. `files.pick_photo` adds an image-filtered document selection path, not a dedicated photo-library grant or large-blob API. Its 1 MiB bound explicitly refuses many original phone photos. See [file-transfer contract](../crates/shell/src/files_service/README.md), `FilesService::api_methods`, `Work::storage` and `handle_event` in [files_service/mod.rs](../crates/shell/src/files_service/mod.rs). +File transfers keep the whole-jail quota and 256-entry bounds. `files.import` takes a document of up to 64 MiB (16 MiB on Android, `max_import_bytes`): a worker stages it beside the jail and the UI links it in between script turns, so its bytes never pass through the script heap. Photo picks and exports keep the 1 MiB per-file bound. Import refuses overwrite and checks ownership, traversal and symlinks. With live app storage, `files.status` also reports `used_bytes` (the host's measure of the app's jail) and `quota_bytes` (the calling isolate's storage quota), so an app can show its storage use without counting its own files. Dialogs and callbacks retain the authenticated app/isolate identity; grants and lifetime are checked again on completion. Closing an app invalidates pending work, but cannot roll back an export whose native write has already started. Android document picks do not retain persistent URI grants. `files.pick_photo` adds an image-filtered document selection path, not a dedicated photo-library grant or large-blob API. Its 1 MiB bound explicitly refuses many original phone photos. See [file-transfer contract](../crates/shell/src/files_service/README.md), `FilesService::api_methods`, `Work::storage` and `handle_event` in [files_service/mod.rs](../crates/shell/src/files_service/mod.rs). Location sampling defaults to a 10-second timeout and a maximum age of 5 seconds. Successful data includes a real timestamp in Unix seconds, `age_ms`, measured `accuracy_m`, `source: "platform"` and `freshness: "fresh"`. Android approximate permission is usable; a stricter requested accuracy can time out instead of silently upgrading permission. App closure, revocation, timeout and host backgrounding release sampling. The older Android `location.get@1` remains unchanged: `source: "last_known"`, `timestamp: null`, `freshness: "unknown"`. It must not be presented as a fresh fix. See [device contract](../crates/shell/src/platform_services/README.md), `DeviceService::api_methods`, and `location::methods` / `Options::value` in `crates/shell/src/platform_services/location.rs`. diff --git a/docs/host-os-api-status.zh-CN.md b/docs/host-os-api-status.zh-CN.md index ee3079b5..e0bbe37b 100644 --- a/docs/host-os-api-status.zh-CN.md +++ b/docs/host-os-api-status.zh-CN.md @@ -18,7 +18,7 @@ | 独立音频 | `microphone.record_start/record_status/record_stop/record_cancel@1`、`audio.play/status/stop@1` 提供使用应用存储、归属应用 isolate、仅限前台的短时会话。录音需要应用和 OS 麦克风授权。 | macOS/Android 源码实现；真实录音和播放仍待验收。不新增 ASR/TTS 或后台流媒体，见[音频会话](../crates/shell/src/audio_service/README.zh-CN.md)。 | | Video 控件操作 | `video.playback_controls@1` 表示 Splash `Video` 控件 ABI，包含准备、播放、暂停／继续、定位、音量／速度和状态／错误查询；**不能通过 `host.request` 调用**。 | macOS 原生播放通过 16 项检查，OnePlus 6 / Android 15 通过 20 项回调／解码器检查。[单独测试](../tools/fixtures/video-api-lab/README.zh-CN.md) 只使用本地合成 MP4；其他编解码器及后端仍未验证。 | -文件传输沿用整个 jail 的字节配额及 256 条目录项限制。`files.import` 可导入最大 64 MiB 的文档（Android 为 16 MiB，见 `max_import_bytes`）：工作线程把它暂存在 jail 旁，UI 在脚本轮次之间把它链接进来，字节不经过脚本堆。图片选择和导出仍使用单文件 1 MiB 上限。导入拒绝覆盖，并检查归属、路径越界和符号链接。对话框及回调使用经认证的应用、isolate 身份，完成时再次检查授权与生命周期。关闭应用使等待中的请求失效，但无法回滚已经开始写入原生目标的导出。Android 文档选择不保留持久 URI 授权。`files.pick_photo` 新增按图片过滤的文档选择路径，不是专用照片库授权或大文件句柄 API。其 1 MiB 上限会明确拒绝很多手机原始照片。详见[文件传输契约](../crates/shell/src/files_service/README.zh-CN.md)，以及 [files_service/mod.rs](../crates/shell/src/files_service/mod.rs) 中的 `FilesService::api_methods`、`Work::storage`、`handle_event`。 +文件传输沿用整个 jail 的字节配额及 256 条目录项限制。`files.import` 可导入最大 64 MiB 的文档（Android 为 16 MiB，见 `max_import_bytes`）：工作线程把它暂存在 jail 旁，UI 在脚本轮次之间把它链接进来，字节不经过脚本堆。图片选择和导出仍使用单文件 1 MiB 上限。导入拒绝覆盖，并检查归属、路径越界和符号链接。有可用的应用存储时，`files.status` 还返回 `used_bytes`（宿主测量的应用 jail 占用）和 `quota_bytes`（调用方隔离实例的存储配额），应用无需自行统计文件即可显示存储用量。对话框及回调使用经认证的应用、isolate 身份，完成时再次检查授权与生命周期。关闭应用使等待中的请求失效，但无法回滚已经开始写入原生目标的导出。Android 文档选择不保留持久 URI 授权。`files.pick_photo` 新增按图片过滤的文档选择路径，不是专用照片库授权或大文件句柄 API。其 1 MiB 上限会明确拒绝很多手机原始照片。详见[文件传输契约](../crates/shell/src/files_service/README.zh-CN.md)，以及 [files_service/mod.rs](../crates/shell/src/files_service/mod.rs) 中的 `FilesService::api_methods`、`Work::storage`、`handle_event`。 位置采样默认超时 10 秒，允许的位置最大年龄为 5 秒。成功结果包含真实 Unix 秒时间戳、`age_ms`、测得的 `accuracy_m`、`source: "platform"`、`freshness: "fresh"`。Android 的大致位置权限可用；如果调用者要求更高精度，可能超时，不会自动提升权限。应用关闭、撤销授权、超时或宿主进入后台都会释放采样。旧 Android `location.get@1` 保持原样：`source: "last_known"`、`timestamp: null`、`freshness: "unknown"`，不能把它显示为刚取得的位置。详见[设备契约](../crates/shell/src/platform_services/README.zh-CN.md)、`DeviceService::api_methods`，以及 `crates/shell/src/platform_services/location.rs` 中的 `location::methods`、`Options::value`。