diff --git a/apps/app/e2e/harness/canvas.html b/apps/app/e2e/harness/canvas.html
new file mode 100644
index 00000000..86ee85f6
--- /dev/null
+++ b/apps/app/e2e/harness/canvas.html
@@ -0,0 +1,12 @@
+
+
+
+
+
+ Canvas harness
+
+
+
+
+
+
diff --git a/apps/app/e2e/harness/canvas.tsx b/apps/app/e2e/harness/canvas.tsx
new file mode 100644
index 00000000..8f033c0e
--- /dev/null
+++ b/apps/app/e2e/harness/canvas.tsx
@@ -0,0 +1,73 @@
+/**
+ * Test page for the editor canvas in a real browser (e2e/ui/canvas-clicks.spec.ts): the
+ * bundled equine sheet in AnatomyCanvas, its drawing's root given the attributes of the
+ * chosen `?drawing=` case, every click recorded. Served by the Vite dev server only
+ * (`/e2e/harness/canvas.html`); the build has a single entry, index.html, so this page
+ * never ships.
+ */
+import { StrictMode, useState } from 'react'
+import { createRoot } from 'react-dom/client'
+import '@/styles/index.css'
+import AnatomyCanvas from '@/components/canvas/AnatomyCanvas'
+import { bundledSheetProvider } from '@/sheets/provider'
+import { setSheetProvider, useSheet } from '@/sheets/useSheet'
+
+/**
+ * Root attributes of the drawing per case (V1-2.2 owner brief 2026-10-30, defect 2): the
+ * reported giant stroke, the same width with no stroke paint (an invisible enlarged
+ * surface), and the hiding stroke properties.
+ */
+const DRAWINGS: Record = {
+ plain: '',
+ 'giant-stroke': 'stroke="#ff00ff" stroke-width="2000"',
+ 'invisible-stroke': 'stroke-width="2000"',
+ 'hidden-stroke': 'stroke="#ff00ff" stroke-width="2000" stroke-opacity="0"',
+}
+
+const params = new URLSearchParams(location.search)
+const rootAttrs = DRAWINGS[params.get('drawing') ?? 'plain'] ?? ''
+const viewId = params.get('view') ?? 'main'
+
+setSheetProvider({
+ async getReferenceSheet(speciesId) {
+ const sheet = await bundledSheetProvider.getReferenceSheet(speciesId)
+ if (!sheet || rootAttrs === '') return sheet
+ const assets = Object.fromEntries(
+ Object.entries(sheet.assets).map(([id, text]) => [
+ id,
+ text.replace('")
+}
+
+fn horse() -> Element {
+ let text = common::repo_file("supabase/seed/anatomical-sheets/equine/draft/assets/horse.svg");
+ read_svg(&text).unwrap().root
+}
+
+fn draft() -> AnatomicalSheetDocument {
+ let text = common::repo_file("supabase/seed/anatomical-sheets/equine/draft/document.json");
+ AnatomicalSheetDocument::deserialize(serde_json::from_str::(&text).unwrap())
+ .unwrap()
+}
+
+/// The composed views of `tree`'s `main` view: the canvas, and the PDF view of `hock`.
+fn composed(tree: &Element) -> [Element; 2] {
+ let ids: HashSet<&str> = ["hock"].into_iter().collect();
+ [
+ compose_canvas(&sheet(), "main", tree).unwrap(),
+ compose_highlight(&sheet(), "main", tree.clone(), &ids, true).unwrap(),
+ ]
+}
+
+fn names(element: &Element) -> Vec<&str> {
+ element.attrs.iter().map(|a| a.qname.as_str()).collect()
+}
+
+/// The marker layer is a child of the composition root, which carries no drawing attribute;
+/// the drawing's root attributes and children live in a group the layer is not part of.
+fn assert_isolated(composed: &Element, drawing: &Element, label: &str) {
+ let root_names = names(composed);
+ assert!(
+ root_names.iter().all(|n| ROOT_ATTRIBUTES.contains(n)),
+ "{label}: composition root carries {root_names:?}"
+ );
+ let layer = composed.element_children().last().unwrap();
+ assert_eq!(layer.qname, "g", "{label}");
+ assert!(layer.element_children().count() > 0, "{label}");
+ let group = composed.element_children().next().unwrap();
+ assert_eq!(group.qname, "g", "{label}: the drawing's group comes first");
+ assert!(!std::ptr::eq(group, layer), "{label}");
+ for attr in &drawing.attrs {
+ let framing = ["xmlns", "xmlns:xlink", "viewBox"].contains(&attr.qname.as_str());
+ if !framing && attr.qname != "id" {
+ assert_eq!(
+ group.attr(&attr.qname),
+ Some(attr.value.as_str()),
+ "{label}: the drawing keeps its own {}",
+ attr.qname
+ );
+ }
+ }
+ assert_eq!(
+ group.element_children().count(),
+ drawing.element_children().count(),
+ "{label}: the drawing's children stay in its group"
+ );
+}
+
+#[test]
+fn no_root_property_of_the_drawing_reaches_a_marker() {
+ for property in ROOT_PROPERTIES {
+ let read = read_svg(&rooted(property)).unwrap_or_else(|e| panic!("{property}: {e:?}"));
+ assert!(read.removed.is_empty(), "{property}: {:?}", read.removed);
+ let [canvas, highlight] = composed(&read.root);
+ assert_isolated(&canvas, &read.root, &format!("canvas {property}"));
+ assert_isolated(&highlight, &read.root, &format!("pdf {property}"));
+ }
+}
+
+#[test]
+fn every_root_property_at_once_stays_with_the_drawing() {
+ let all = ROOT_PROPERTIES.join(" ");
+ let read = read_svg(&rooted(&all)).unwrap();
+ let [canvas, highlight] = composed(&read.root);
+ assert_isolated(&canvas, &read.root, "canvas");
+ assert_isolated(&highlight, &read.root, "pdf");
+}
+
+/// The equine drawing keeps its root attributes (`font-family`, `font-size`) on its group and
+/// its frame on the composition root, in both forms.
+#[test]
+fn the_equine_drawing_is_isolated_in_both_forms() {
+ let horse = horse();
+ let draft = draft();
+ let ids: HashSet<&str> = ["hock", "hip"].into_iter().collect();
+ let canvas = compose_canvas(&draft, "main", &horse).unwrap();
+ let highlight = compose_highlight(&draft, "main", horse.clone(), &ids, true).unwrap();
+ for (label, view) in [("canvas", &canvas), ("pdf", &highlight)] {
+ assert_isolated(view, &horse, label);
+ assert_eq!(view.attr("viewBox"), Some("0 0 2073.4 1629.4"), "{label}");
+ }
+}
+
+/// The halo filter is the engine's: outside the drawing's group, so no property of the
+/// drawing (`color-interpolation-filters` on its root or its ``) changes the halo.
+#[test]
+fn the_halo_filter_lives_outside_the_drawing() {
+ let read = read_svg(&rooted(
+ "color-interpolation-filters=\"sRGB\" stroke-width=\"400\"",
+ ))
+ .unwrap();
+ let [_, highlight] = composed(&read.root);
+ let group = highlight.element_children().next().unwrap();
+ let mut inside = Vec::new();
+ common::sheet_readers::holders(group, "osteo-halo", &mut inside);
+ assert!(inside.is_empty(), "the halo is not in the drawing's group");
+ let mut everywhere = Vec::new();
+ common::sheet_readers::holders(&highlight, "osteo-halo", &mut everywhere);
+ assert_eq!(everywhere.len(), 1);
+}
+
+/// Every interactive surface of the canvas: the point hitboxes declare `stroke="none"` and
+/// capture on their circle only (`visibleFill`), the zones and the trigger declare their
+/// stroke width; the visible twins never capture.
+#[test]
+fn every_interactive_surface_declares_its_geometry_and_capture() {
+ let draft = draft();
+ let canvas = compose_canvas(&draft, "main", &horse()).unwrap();
+ let layer = canvas.element_children().last().unwrap();
+ let mut hitboxes = 0;
+ for marker in layer.element_children() {
+ match (marker.attr("fill"), marker.attr("pointer-events")) {
+ (Some("transparent"), capture) => {
+ hitboxes += 1;
+ assert_eq!(marker.attr("stroke"), Some("none"), "{marker:?}");
+ assert_eq!(capture, Some("visibleFill"), "{marker:?}");
+ }
+ (_, Some("none")) => {}
+ (_, Some("all")) => assert!(marker.attr("stroke-width").is_some(), "{marker:?}"),
+ other => panic!("unexpected capture {other:?}"),
+ }
+ }
+ assert_eq!(hitboxes, 13, "the 13 points of the main view");
+}
+
+/// A value for each attribute the reader keeps, chosen to change a marker if it reached one.
+fn hostile_value(name: &str) -> &'static str {
+ match name {
+ "fill" | "stroke" | "color" | "stop-color" | "flood-color" => "#ff00ff",
+ "opacity" | "fill-opacity" | "stroke-opacity" | "stop-opacity" | "flood-opacity" => "0",
+ "display" => "none",
+ "visibility" => "visible",
+ "fill-rule" | "clip-rule" => "evenodd",
+ "stroke-dasharray" => "0 1000",
+ "stroke-linecap" => "square",
+ "stroke-linejoin" => "miter",
+ "preserveAspectRatio" => "xMinYMin slice",
+ "maskUnits" | "maskContentUnits" | "clipPathUnits" => "userSpaceOnUse",
+ "color-interpolation-filters" => "sRGB",
+ "font-family" => "serif",
+ "font-weight" => "bold",
+ "systemLanguage" => "xx",
+ "points" => "0,0 9,9 0,9",
+ "d" => "M0 0h9",
+ _ => "400",
+ }
+}
+
+/// CSS a drawing's descendant may carry in `style`, including what could act outside its own
+/// subtree in an HTML page (stacking, positioning, compositing, outlines, view transitions).
+/// The browser probe of 2026-11-01 drew a full-frame opaque rectangle with each of them below
+/// the layer: no marker pixel changed and every point kept its click, in the three engines.
+const DESCENDANT_STYLES: [&str; 17] = [
+ "position:relative;z-index:2147483647",
+ "position:fixed;inset:0;z-index:9999",
+ "mix-blend-mode:normal;isolation:isolate",
+ "view-transition-name:hijack",
+ "outline:4000px solid #ff00ff;outline-offset:0",
+ "contain:strict;content-visibility:visible",
+ "paint-order:markers stroke fill",
+ "stroke:#ff00ff;stroke-width:100000",
+ "pointer-events:all;cursor:pointer",
+ "opacity:0",
+ "display:none",
+ "visibility:hidden",
+ "translate:0 0 9999px",
+ "order:-1;float:right",
+ "anchor-name:--x;position-anchor:--x",
+ "fill-opacity:0;stroke-opacity:0",
+ "font-size:900px",
+];
+
+fn layer_and_defs(composed: &Element) -> String {
+ composed
+ .element_children()
+ .skip(1)
+ .map(faunosteo_core::anatomy::svg::serialize::serialize)
+ .collect()
+}
+
+/// Census over the reader's whole attribute allowlist (owner brief 2026-11-01): whatever the
+/// drawing's root or descendants keep, the composition root carries only namespaces and the
+/// frame, and the layer and the halo serialise byte for byte as with a plain drawing.
+#[test]
+fn nothing_the_reader_keeps_changes_the_layer_or_the_halo() {
+ let plain = read_svg(&rooted("")).unwrap().root;
+ let expected = composed(&plain).map(|view| layer_and_defs(&view));
+ let structural = [
+ "xmlns",
+ "xmlns:xlink",
+ "viewBox",
+ "id",
+ "href",
+ "xlink:href",
+ "style",
+ ];
+ let mut root_cases: Vec = sanitize::ALLOWED_ATTRIBUTES
+ .iter()
+ .filter(|name| !structural.contains(name))
+ .map(|name| format!("{name}=\"{}\"", hostile_value(name)))
+ .collect();
+ root_cases.push(String::new());
+ for attrs in &root_cases {
+ let text = rooted(attrs).replace(BODY, &format!("{BODY}"));
+ let read = read_svg(&text).unwrap_or_else(|e| panic!("{attrs}: {e:?}"));
+ for (view, want) in composed(&read.root).iter().zip(&expected) {
+ assert!(
+ names(view).iter().all(|n| ROOT_ATTRIBUTES.contains(n)),
+ "{attrs}"
+ );
+ assert_eq!(&layer_and_defs(view), want, "{attrs}");
+ }
+ }
+ for style in DESCENDANT_STYLES {
+ let body = format!(
+ "{BODY}"
+ );
+ let read = read_svg(&rooted("").replace(BODY, &body)).unwrap();
+ let kept = faunosteo_core::anatomy::svg::serialize::serialize(&read.root);
+ assert!(
+ kept.contains(style),
+ "{style}: the reader keeps it, {:?}",
+ read.removed
+ );
+ for (view, want) in composed(&read.root).iter().zip(&expected) {
+ assert!(
+ names(view).iter().all(|n| ROOT_ATTRIBUTES.contains(n)),
+ "{style}"
+ );
+ assert_eq!(&layer_and_defs(view), want, "{style}");
+ }
+ }
+}
diff --git a/crates/core/tests/svg_root_visibility.rs b/crates/core/tests/svg_root_visibility.rs
index 34369a97..d9b0a384 100644
--- a/crates/core/tests/svg_root_visibility.rs
+++ b/crates/core/tests/svg_root_visibility.rs
@@ -1,7 +1,7 @@
//! V1-2.2 owner brief 2026-10-30: the drawing's root never decides whether the engine's markers
-//! show. Both composers append the marker layer as the root's last child (the PDF view keeps the
-//! drawing's root, the canvas copies its attributes), so the layer inherits the root's
-//! `visibility`; a drawing `