Skip to content

armgit / klad

Public Imported from GitHub
0

A drawing app built for agent/human collaboration

Rust

Support reachable from the app

Indicode BV481a6a6ac07f
diff --git a/CHANGELOG.md b/CHANGELOG.md
index edd48e9..d71787b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,7 @@ The first builds, and klad's licences.
- In-betweens blend colours evenly (in OKLab), so light can follow a turning limb when the second key is coloured for it.
- `klad arcs` follows the part of a foot on the ground: a heel-to-toe roll is no longer reported as a slide.
- Help > Report a problem shows the report before it is copied (version, system, the last messages and lines of klad's log, with your home folder hidden) and can zip the drawing to attach; `klad report` prints the same. Errors and crashes are kept in a small log for it.
+- Support by email: Help > Contact support opens an email to [email protected] with the version and your system filled in; Report a problem can email its report there too, and About links klad.studio and the address. Crash messages name the address as well as the issues page.
- Messages say what happened and what to do next; when klad itself goes wrong it says so, and that your work is saved.
- Bones: a bones layer holds a skeleton (`klad bone`, the bone tool J), weights from the bones or painted (`klad weights`), and poses that bend the drawing (`klad pose`, pose mode); in-betweens of two poses turn the bones. The bone tool lists the skeleton, picks a bone in every mode, and moves ends, joints and whole bones with their children (`klad bone --move` with `--by`).
- Transform a whole layer or group: cmd T puts handles round it, and a drag moves, turns or scales every drawing on it, its shapes, and its bones and poses (`klad transform --layer`).
diff --git a/crates/app/src/commands.rs b/crates/app/src/commands.rs
index a7800c8..2e3ce8e 100644
--- a/crates/app/src/commands.rs
+++ b/crates/app/src/commands.rs
@@ -153,6 +153,7 @@ pub enum Cmd {
CopyPath,
InstallCommand,
ReportProblem,
+ ContactSupport,
PaintOver,
CompareReference,
About,
@@ -493,7 +494,7 @@ use Repeat as R;
use Trigger as T;
impl Cmd {
- pub const ALL: [Cmd; 166] = [
+ pub const ALL: [Cmd; 167] = [
Cmd::Brush,
Cmd::Eraser,
Cmd::Fill,
@@ -650,6 +651,7 @@ impl Cmd {
Cmd::CopyPath,
Cmd::InstallCommand,
Cmd::ReportProblem,
+ Cmd::ContactSupport,
Cmd::About,
Cmd::Export,
Cmd::AddFont,
@@ -2129,7 +2131,16 @@ impl Cmd {
G::File,
T::None,
R::No,
- "copies the version, the system and the last messages, to paste into an issue on GitHub",
+ "the version, the system and the last messages, to email to support or paste into an issue on GitHub",
+ ),
+ Cmd::ContactSupport => spec(
+ "help.contact",
+ "contact support",
+ icon::NOTE,
+ G::File,
+ T::None,
+ R::No,
+ "an email to klad's support in your email app, with the version and your system filled in",
),
Cmd::InstallCommand => spec(
"file.install-command",
@@ -2305,6 +2316,7 @@ impl Cmd {
Cmd::CopyPath => "Copy path",
Cmd::InstallCommand => "Install the klad command",
Cmd::ReportProblem => "Report a problem…",
+ Cmd::ContactSupport => "Contact support",
Cmd::PaintOver => "Paint over…",
Cmd::CompareReference => "Compare with reference",
Cmd::About => "About klad and licences",
@@ -2609,6 +2621,7 @@ pub const MENUS: [Menu; 9] = [
Run(Cmd::Palette),
Run(Cmd::Keys),
Line,
+ Run(Cmd::ContactSupport),
Run(Cmd::ReportProblem),
Run(Cmd::About),
],
diff --git a/crates/app/src/editor.rs b/crates/app/src/editor.rs
index c4f84f7..84599b1 100644
--- a/crates/app/src/editor.rs
+++ b/crates/app/src/editor.rs
@@ -653,6 +653,8 @@ pub(crate) struct Editor {
first: first::FirstSteps,
settings_section: prefs::Section,
report_drawing: bool,
+ #[cfg(test)]
+ pub(crate) opened: Vec<String>,
soloed: Option<(String, Vec<(String, bool)>)>,
strip_tools: [f32; 2],
strip_foot: [f32; 2],
@@ -829,6 +831,8 @@ impl Editor {
first: first::FirstSteps::default(),
settings_section: prefs::Section::default(),
report_drawing: false,
+ #[cfg(test)]
+ opened: Vec::new(),
soloed: None,
strip_tools: [570.0, 480.0],
strip_foot: [186.0, 166.0],
diff --git a/crates/app/src/editor/commands.rs b/crates/app/src/editor/commands.rs
index 5faaeaa..f7da08d 100644
--- a/crates/app/src/editor/commands.rs
+++ b/crates/app/src/editor/commands.rs
@@ -671,6 +671,7 @@ impl Editor {
Cmd::ShowArcs => self.show_arcs()?,
Cmd::InstallCommand => self.start_job(install_job()),
Cmd::ReportProblem => self.windows.report = !self.windows.report,
+ Cmd::ContactSupport => self.contact_support(),
Cmd::CopyPath => {
let path = self.scene.bundle.root.display().to_string();
self.ctx.copy_text(path.clone());
@@ -1035,16 +1036,32 @@ impl Editor {
.text()
}
+ pub(crate) fn open_link(&mut self, url: String) {
+ #[cfg(test)]
+ self.opened.push(url.clone());
+ self.ctx.open_url(egui::OpenUrl::new_tab(url));
+ }
+
+ fn contact_support(&mut self) {
+ let body = format!(
+ "What I need help with:\n\n\n\nklad {}, {}\n",
+ crate::VERSION,
+ crate::report::system()
+ );
+ self.open_link(klad_core::contact::mailto(&format!("klad {}", crate::VERSION), &body));
+ }
+
pub(super) fn report_panel(&mut self, ui: &mut egui::Ui) {
ui.add(
- egui::Label::new(
- "Paste this into a new issue on klad's GitHub page. It holds klad's version, your system, the last messages and the last lines of klad's log; klad sends nothing by itself.",
- )
+ egui::Label::new(format!(
+ "Email this to support ({}) or paste it into a new issue on klad's GitHub page. It holds klad's version, your system, the last messages and the last lines of klad's log; klad sends nothing by itself.",
+ klad_core::contact::SUPPORT
+ ))
.wrap(),
);
ui.checkbox(
&mut self.report_drawing,
- "include the drawing: a zip next to it, to attach to the issue",
+ "include the drawing: a zip next to it, to attach",
)
.hint("the drawing without its cache, so whoever reads the issue sees what you see");
let text = self.problem_report(None);
@@ -1059,21 +1076,61 @@ impl Editor {
{
self.copy_report();
}
+ if ui
+ .button("email it to support")
+ .hint(format!(
+ "opens an email to {} with the report in it",
+ klad_core::contact::SUPPORT
+ ))
+ .clicked()
+ {
+ self.email_report();
+ }
ui.hyperlink_to("open klad's issues", crate::report::ISSUES)
.hint("a new issue on GitHub, in your browser");
});
}
- fn copy_report(&mut self) {
- let attached = match self.report_drawing {
+ fn report_zip(&mut self) -> Result<Option<std::path::PathBuf>, ()> {
+ match self.report_drawing {
true => match crate::report::zip_beside(&self.scene.bundle.root) {
- Ok(zip) => Some(zip),
+ Ok(zip) => Ok(Some(zip)),
Err(e) => {
self.failed(e.context("the drawing could not be zipped for the report"));
- return;
+ Err(())
}
},
- false => None,
+ false => Ok(None),
+ }
+ }
+
+ fn email_report(&mut self) {
+ let Ok(attached) = self.report_zip() else {
+ return;
+ };
+ let report = self.problem_report(attached.as_deref());
+ self.open_link(klad_core::contact::mailto(
+ &format!("klad {}: a problem", crate::VERSION),
+ &report,
+ ));
+ match attached {
+ Some(zip) => self.say(
+ Tone::Done,
+ format!(
+ "your email app opens with the report: attach {} and send it",
+ zip.display()
+ ),
+ ),
+ None => self.say(
+ Tone::Done,
+ "your email app opens with the report: add what happened and send it",
+ ),
+ }
+ }
+
+ fn copy_report(&mut self) {
+ let Ok(attached) = self.report_zip() else {
+ return;
};
self.ctx.copy_text(self.problem_report(attached.as_deref()));
match attached {
diff --git a/crates/app/src/editor/panels.rs b/crates/app/src/editor/panels.rs
index 145f6a2..38f413e 100644
--- a/crates/app/src/editor/panels.rs
+++ b/crates/app/src/editor/panels.rs
@@ -484,6 +484,16 @@ impl Editor {
ui.label(RichText::new(format!("klad {}", crate::VERSION)).strong());
self.update_rows(ui);
ui.label("Source-available licence, copyright Indicode BV. Built on the open source work listed below; klad licences prints the same.");
+ ui.horizontal(|ui| {
+ ui.hyperlink_to("klad.studio", klad_core::contact::SITE)
+ .hint("klad's website: the guides, what's new and your download");
+ ui.label(RichText::new("·").color(theme::WEAK));
+ ui.hyperlink_to(
+ klad_core::contact::SUPPORT,
+ format!("mailto:{}", klad_core::contact::SUPPORT),
+ )
+ .hint("support, by email");
+ });
ui.add_space(6.0);
ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);
let row = ui.text_style_height(&egui::TextStyle::Small);
diff --git a/crates/app/src/editor/ui_tests.rs b/crates/app/src/editor/ui_tests.rs
index aa82b2b..a90a957 100644
--- a/crates/app/src/editor/ui_tests.rs
+++ b/crates/app/src/editor/ui_tests.rs
@@ -4113,7 +4113,7 @@ fn a_forced_error_reads_as_a_sentence_and_lands_in_the_report_with_the_drawing()
let said = h.state().messages.log().last().unwrap().text.clone();
assert!(
said.starts_with("something went wrong inside klad (the frames could not be prepared: a test forced this)")
- && said.ends_with("Help > Report a problem copies what an issue needs"),
+ && said.ends_with("Help > Report a problem sends it to [email protected] or to klad's issues"),
"{said}"
);
assert!(
@@ -4132,6 +4132,13 @@ fn a_forced_error_reads_as_a_sentence_and_lands_in_the_report_with_the_drawing()
path.file_stem().unwrap().to_string_lossy()
));
assert!(zip.is_file(), "the drawing is zipped next to it");
+ h.get_by_label("email it to support").click();
+ h.run_steps(2);
+ let mail = h.state().opened.last().cloned().unwrap_or_default();
+ assert!(
+ mail.starts_with("mailto:[email protected]?subject=klad%20") && mail.contains("a%20test%20forced%20this"),
+ "the report goes into an email to support: {mail}"
+ );
let names = crate::report::unzip_names(&std::fs::read(&zip).unwrap());
assert!(names.iter().any(|(n, ok)| n.ends_with("/doc.json") && *ok));
let report = h.state().problem_report(Some(&zip));
@@ -4278,3 +4285,32 @@ fn guide_pictures() {
std::fs::remove_dir_all(&dir).unwrap();
});
}
+
+#[test]
+fn help_reaches_support_by_email_and_about_links_the_site() {
+ let path = sample("support");
+ let mut h = harness(editor(&path), vec2(1440.0, 1000.0));
+ h.state_mut().invoke(Cmd::ContactSupport).unwrap();
+ h.run_steps(1);
+ let mail = h.state().opened.last().cloned().unwrap_or_default();
+ let encoded = |text: &str| {
+ klad_core::contact::mailto("", text)
+ .split("body=")
+ .nth(1)
+ .unwrap_or_default()
+ .to_string()
+ };
+ assert!(mail.starts_with("mailto:[email protected]?subject=klad%20"), "{mail}");
+ assert!(
+ mail.contains(&encoded(crate::VERSION)) && mail.contains(&encoded(&crate::report::system())),
+ "the email holds the version and the system: {mail}"
+ );
+ h.state_mut().invoke(Cmd::About).unwrap();
+ h.run_steps(2);
+ assert!(h.query_by_label("klad.studio").is_some(), "About links the website");
+ assert!(
+ h.query_by_label("[email protected]").is_some(),
+ "and the support address"
+ );
+ let _ = std::fs::remove_dir_all(&path);
+}
diff --git a/crates/app/src/report.rs b/crates/app/src/report.rs
index 32c8378..ced69c6 100644
--- a/crates/app/src/report.rs
+++ b/crates/app/src/report.rs
@@ -32,7 +32,8 @@ pub fn job_failed(name: &str, why: &str) -> String {
Some((_, rest)) => {
let what = rest.split(". KLAD_BACKTRACE").next().unwrap_or(rest);
format!(
- "something went wrong inside klad ({name}: {what}). Everything up to your last edit is saved; Help > Report a problem copies what an issue needs"
+ "something went wrong inside klad ({name}: {what}). Everything up to your last edit is saved; Help > Report a problem sends it to {} or to klad's issues",
+ klad_core::contact::SUPPORT
)
}
None => format!("{name} did not finish: {why}"),
@@ -49,7 +50,8 @@ pub fn is_bug(e: &anyhow::Error) -> bool {
pub fn bug_message(e: &anyhow::Error) -> String {
format!(
- "something went wrong inside klad ({e:#}). Everything up to your last edit is saved; Help > Report a problem copies what an issue needs"
+ "something went wrong inside klad ({e:#}). Everything up to your last edit is saved; Help > Report a problem sends it to {} or to klad's issues",
+ klad_core::contact::SUPPORT
)
}
@@ -331,7 +333,7 @@ mod tests {
);
let crashed = job_failed(
"pose at frame 4",
- "error: klad hit a bug: index out of bounds at crates/core/src/rig.rs:10. KLAD_BACKTRACE=1 shows the details; please report it at https://github.com/klad-app/klad/issues",
+ "error: klad hit a bug: index out of bounds at crates/core/src/rig.rs:10. KLAD_BACKTRACE=1 shows the details; please report it to [email protected] or at https://github.com/klad-app/klad/issues",
);
assert!(crashed.starts_with(
"something went wrong inside klad (pose at frame 4: index out of bounds at crates/core/src/rig.rs:10)"
diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
index 202d3e3..7e92996 100644
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -1996,8 +1996,10 @@ fn bug(info: &std::panic::PanicHookInfo) -> String {
.map(|l| format!(" at {}:{}", l.file(), l.line()))
.unwrap_or_default();
format!(
- "klad hit a bug: {}{place}. KLAD_BACKTRACE=1 shows the details; please report it at https://github.com/klad-app/klad/issues",
- what.replace('\n', " ")
+ "klad hit a bug: {}{place}. KLAD_BACKTRACE=1 shows the details; please report it to {} or at {}",
+ what.replace('\n', " "),
+ klad_core::contact::SUPPORT,
+ klad_core::contact::ISSUES
)
}
diff --git a/crates/core/src/contact.rs b/crates/core/src/contact.rs
new file mode 100644
index 0000000..de9ec75
--- /dev/null
+++ b/crates/core/src/contact.rs
@@ -0,0 +1,33 @@
+pub const SUPPORT: &str = "[email protected]";
+pub const SITE: &str = "https://klad.studio";
+pub const ISSUES: &str = "https://github.com/klad-app/klad/issues";
+
+pub fn mailto(subject: &str, body: &str) -> String {
+ format!(
+ "mailto:{SUPPORT}?subject={}&body={}",
+ encode(subject),
+ encode(&body.replace("\r\n", "\n").replace('\n', "\r\n"))
+ )
+}
+
+fn encode(text: &str) -> String {
+ text.bytes()
+ .map(|b| match b {
+ b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => (b as char).to_string(),
+ _ => format!("%{b:02X}"),
+ })
+ .collect()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn a_mail_to_support_keeps_its_lines_and_spaces() {
+ assert_eq!(
+ mailto("klad 1.0: help", "line one\nline 2 & more"),
+ "mailto:[email protected]?subject=klad%201.0%3A%20help&body=line%20one%0D%0Aline%202%20%26%20more"
+ );
+ }
+}
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
index 7b5c5c7..b736502 100644
--- a/crates/core/src/lib.rs
+++ b/crates/core/src/lib.rs
@@ -1,6 +1,7 @@
pub mod brushes;
pub mod bundle;
pub mod color;
+pub mod contact;
pub mod cut;
pub mod doc;
pub mod fill;
diff --git a/docs/DESIGN.md b/docs/DESIGN.md
index 440879f..b266a6f 100644
--- a/docs/DESIGN.md
+++ b/docs/DESIGN.md
@@ -439,7 +439,7 @@ Scripts are any language that prints edit ops as JSON lines into `klad apply`. G
- Commands (M4 batch 1): every editor action is a `Cmd` in one list (`commands.rs`): an id (`tool.brush`, `drawing.new`, kept in settings), a name in plain words, a Phosphor icon, a group, its keys or the hold that triggers it, whether a held key repeats it, and a line on what it does. Keys, the strip, panel buttons, the timeline's buttons and context menu, and the palette all run commands through `Editor::invoke`, which first asks `can_run` (a reason when it cannot, shown as a refusal) and remembers the last twelve run. A key matches only with exactly its modifiers (shift K is not K); key repeats run commands that repeat (`=`, `[`, cmd Z) and frame steps only once the frame on screen caught up. cmd K opens the palette: type to filter (name start, then a key, a word, a substring, the letters in order, the group; hyphens ignored, so "inb" finds in-between), arrows and Return run, rows grey out with the reason, recent commands first; `?` opens it too. Every control has a hover hint after 0.35 s (from its command where there is one) and is at least 24 pt high; a test walks every control of every panel and window to keep it so.
- Tool options and selections (M4 batch 2): a bar over the canvas holds the active tool's settings (brush: picker, size, opacity, flow, and a "more" menu for hardness, lightest size, curve, taper, stabiliser and smoothing; fill: reference, gap, tolerance, grow, opacity; strokes: cut at the lasso edge, select all; points: corner, smooth, simplify, make it a path). The strip shows the eraser while the eraser brush or the pen's eraser end is on, and two colours (the current one over the second; X or a click swaps them; picking a colour from a swatch, the hex field or the eyedropper makes the old one the second). cmd alt drag sideways on the canvas sizes the brush (doubling every 120 pt), the circle staying where the drag began. H flips the view left-right (the view's mappings and the GPU matrix mirror; the document does not change); the status line's zoom takes a click for 100% and a double-click to fit, its rotation a click to turn upright. A selection bar sits under (or over) the selection's box: for strokes flips, quarter turns, recolour, thinner, thicker, opacity, copy, paste, duplicate in place, delete, deselect; for a shape flips (sx or sy negated and its rotation mirrored), quarter turns, fill with the colour and outline in the colour (rectangles, ellipses, paths and text: `fill`, or `stroke.paint`, or a new `stroke` at the pen's width when it had none; Edit > Shape; `klad set <id> fill=...` is the CLI form), duplicate in place (an `add` of the node without ids, above it), delete, deselect; for points corner, smooth, nudges, delete. Arrows nudge strokes, a shape or points by 1 px, 10 px with shift. Strokes select across layers (M5 batch 2 round 1): cmd or shift click on rows in the layers panel adds paint layers to the active one (marked with a blue edge); S then lassos, clicks and selects all on all of them, and the selection (one part per layer) moves, turns, scales, flips, recolours, cuts at the lasso edge, copies and deletes as one edit, each layer's marks staying on their layer. A selection on several layers moves as one edit, each layer previewed while it is dragged; copies of several layers paste back into their own layers, a copy of one layer into the active one. The strip's panels button lists the six panels and the timeline with a tick each, so a closed panel always has a way back. U draws rectangles and ellipses on a vector layer (shift for a square or circle, alt from the centre, rounded corners for rectangles; fill, outline and width shared with the pen, the fill in the first colour and the outline in the second, as for the pen's paths) as `rect` and `ellipse` nodes. Mirror painting (the brush bar's "mirror" and its axis) paints every stroke's mirror image as it is drawn, in a second stroke buffer landed after the first, and commits both as plain marks in one history step. Handles are drawn at 12 pt and hit within 12 pt (`grab`); a press becomes a drag once it has moved 3 pt on screen, so a tap that wobbles selects and does not move; shapes whose rotation is a quarter turn get edge handles too (`lift::stretched` scales their own axis). Pen events that arrive while a point edit is being written are held and replayed in order after it. The colour pane shows the picker and the palette (swatches drag to reorder; the x in a hovered swatch's corner, or a right-click, removes it) and recent colours; the brush pane (its own since 2026-11-08, Kevin: "make brush its own palette, like colour and layers") the size presets and the brushes as tiles, each with a sample stroke drawn by `klad-brush` once per brush definition. A saved layout without a pane gets it after the pane it follows by default.
- First start (S8.7, `start.rs`, `editor/first.rs`, `klad_core::samples`): until the settings say `welcomed` (set when any drawing opens, or by "Not now"), the start window opens with a welcome offering first steps. First steps make `first steps.klad` (1280 by 800 on paper, one paint layer) in the drawings folder and open it with a small window of three steps that tick as they happen: a brush stroke is saved, a fill is saved, the request for an agent is copied (a sentence with the drawing's path asking the agent to read `klad skill`, render the drawing and add a shadow; "install the klad command" sits next to it). Help > First steps opens and closes the window on any drawing. The checklist is the editor's alone: it teaches the hands on the canvas, and an agent's first steps are `klad skill`. Revisit the third step when klad is an MCP server (S8.10). Under the recent drawings the start window shows the samples: the drawings `samples/shipped.json` names (name, bundle, a line on what it shows), each a card with its thumbnail and that line; a click copies it into the drawings folder without its `.cache` (`samples::copy`, `<name>.klad` or `<name> 2.klad`) and opens the copy, so a sample is never changed. `klad samples` lists the same set and `--copy <name> [--into folder]` copies one (default the current folder). Samples are found like the fonts: `KLAD_SAMPLES`, then `samples/` next to the binary, `../Resources/samples`, `../share/klad/samples`, and a source checkout's `samples/` up to five folders above the binary (where they exist after `just samples`; a sample not built is left out). `packaging/samples.sh` puts them in every build: it builds any that are missing with that build's `klad` (through the sample's `build.sh`, `PYTHON` naming the interpreter), copies them without caches, and renders each one's `<name>.thumb.png` next to it at 336 px, so the start window never renders into the app (a thumbnail outside the bundle is used as it is; only recent drawings' `.cache/thumb.png` are remade when the drawing changes). `app.sh` puts them in `Resources/samples`, `archive.sh` in the archive's `samples/` and the AppImage's `usr/share/klad/samples`; the six weigh about 4 MB.
-- Messages and problem reports (S8.8, `report.rs`): a message says what happened and what to do next ("nothing to fill there: click inside closed lines, or raise the gap so small openings close"); a refusal names the step that makes the command possible. Errors that mean klad itself went wrong (an invariant broken, a picture missing that should be there) are `report::Bug`s: the editor says "something went wrong inside klad (what), everything up to your last edit is saved; Help > Report a problem copies what an issue needs" instead of the bare detail; a job whose CLI crashed reads the same, and a job that failed says "<job> did not finish: <the CLI's reason>". Every error message, job failure and crash of the editor or the CLI is appended to `klad.log` next to the settings (`KLAD_LOG` overrides it; past 512 KB the older half goes), one dated line each. Help > Report a problem opens a window with the report as it will be copied: klad's version and where it ran, the system (macOS version, the Linux distribution, Windows' version, and the processor), a place for what happened, the drawing's size, the last 40 messages and the last 40 lines of the log, with the home folder written as `~` and the drawing's folder as `<the drawing's folder>`. "include the drawing" zips the drawing without its cache next to it (`<name> for a report.zip`, stored entries, written by klad itself) and the report names the file to attach; "copy the report" copies it and "open klad's issues" opens GitHub. Nothing is sent by klad. `klad report [--drawing <bundle>]` prints the same report from the command line (version, system, log, the drawing zipped).
+- Messages and problem reports (S8.8, `report.rs`): a message says what happened and what to do next ("nothing to fill there: click inside closed lines, or raise the gap so small openings close"); a refusal names the step that makes the command possible. Errors that mean klad itself went wrong (an invariant broken, a picture missing that should be there) are `report::Bug`s: the editor says "something went wrong inside klad (what), everything up to your last edit is saved; Help > Report a problem sends it to [email protected] or to klad's issues" instead of the bare detail; a job whose CLI crashed reads the same, and a job that failed says "<job> did not finish: <the CLI's reason>". Every error message, job failure and crash of the editor or the CLI is appended to `klad.log` next to the settings (`KLAD_LOG` overrides it; past 512 KB the older half goes), one dated line each. Help > Report a problem opens a window with the report as it will be copied: klad's version and where it ran, the system (macOS version, the Linux distribution, Windows' version, and the processor), a place for what happened, the drawing's size, the last 40 messages and the last 40 lines of the log, with the home folder written as `~` and the drawing's folder as `<the drawing's folder>`. "include the drawing" zips the drawing without its cache next to it (`<name> for a report.zip`, stored entries, written by klad itself) and the report names the file to attach; "copy the report" copies it, "email it to support" opens an email to the support address with the report in it (the person attaches the zip), and "open klad's issues" opens GitHub. Help > Contact support opens an email with the version and the system filled in, and About links klad.studio and the address. The address, the site and the issues page are constants in `klad_core::contact`; the site's sync reads the address from there. Nothing is sent by klad. `klad report [--drawing <bundle>]` prints the same report from the command line (version, system, log, the drawing zipped).
- Menus (S8.6, `commands::MENUS`, `menus.rs`): one list of menus holds every command but the holds (pan, zoom, the eyedropper, flipping, rolling, the parallax preview and sizing on the canvas, which are gestures), so the menus, the palette and the keys stay one list; a test fails when a command is in no menu or in two. The menus, in order: File (new, open, recent, close; import; export; the path and the command line tool), Edit (undo; copy, paste, duplicate, delete; selecting; Transform, Strokes and Points submenus), Tools (the tools, the brush, the colours), Layer (new, duplicate, rename, group, delete; show, lock, clip, lock alpha; Mask and Shape generators submenus, paint over; refill and gaps), Frame (stepping, drawings, holds and moves, inserting and removing frames), Animation (playback, onion skin, exposure, Selected frames and Clip submenus, the checks across frames), View (zoom, rotation, flip, the reference), Window (the panels, the message log, numbers) and Help. Each command has a short menu label (`Cmd::menu`: "Show", "Clip to layer below", "Export…"), since the menu says what it acts on, while the palette and hints keep the longer names; "…" marks a command that opens a window. Items show one key each (Backspace for delete); toggles show a tick, except commands that open a window; a command that cannot run now is greyed out (its reason is the palette's). A test keeps labels unique in each menu and under 30 characters. On macOS the list becomes the system menu bar (`menus::install`, rebuilt when the keys or the recent drawings change): an app menu with About, Settings, Services, hide and Quit, then the list, whose Window menu also gets the system's Minimize, Zoom and Bring all to front (it is the app's windows menu). Items target one Objective-C object (`KladMenuTarget`, `define_class!`) whose `kladRun:` queues the command for the next frame (the editor runs it through `Editor::invoke` as any key would) and whose `validateMenuItem:` reads a snapshot of what is off and on that the app refreshes every 0.4 s. The item keys are shown but not claimed: the object is each menu's delegate and answers no to `menuHasKeyEquivalent:forEvent:target:action:`, so a key still reaches the editor's own dispatch (which knows holds, repeats and text fields) and nothing runs twice; only the app menu's own keys (cmd , cmd Q cmd H) and Window's cmd M are AppKit's. On Windows and Linux (and in tests) the same list is an egui menu bar over the window, hidden with the panels (Tab). File > Open recent lists the last ten drawings; File > Close the drawing (cmd W, refused while a job runs) goes back to the start window, where only new, open, recent and quit run. Settings and Quit sit in the app menu on macOS and in Edit and File elsewhere; About (with the licences) is in Help everywhere and also in the macOS app menu.
- Messages and jobs (M4 batch 1): every result, refusal and error goes through `Editor::say` with a tone (info, done, refused, error). Done and refused messages show for 3.5 and 6 s as a toast in the bottom left corner of the canvas, newest lowest (2026-11-08: they used to follow the pointer, which got in the way), errors until dismissed, info only in the status line; the status line shows the latest message (a click opens the message log, the last 200 with times), the frame, where the next stroke goes ("draws into c12 on lines, frames 4 to 7"), running jobs with a cancel button, slow internal work (preparing a selection, drawing an edited path, loading a frame), zoom and rotation. Times that used to be status text (stroke, fill, edit, undo, sync, frame step, last play, last job) are kept by name for the numbers window. Background jobs (in-betweens, Godot export) run the same `klad` binary through one job list (`jobs.rs`); when the CLI exits with code 75 (the document changed while it computed) the job runs again, up to three times, so an edit made in the editor meanwhile is never overwritten.
- Tools: brush, eraser, smudge, fill (inside lines, gap closing), lasso select and transform, move/rotate/scale handles, path point editing, eyedropper.