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('([]) + return ( +
+

Canvas harness

+ {/* A fixed height: the canvas never moves when the first click is listed. */} + + {clicks.join(' ')} + +
+ {sheet.status === 'ready' && ( + setClicks((all) => [...all, id])} + /> + )} +
+ + ) +} + +createRoot(document.getElementById('root') as HTMLElement).render( + + + , +) diff --git a/apps/app/e2e/playwright.ui.config.ts b/apps/app/e2e/playwright.ui.config.ts index 4b61a066..4ed2c318 100644 --- a/apps/app/e2e/playwright.ui.config.ts +++ b/apps/app/e2e/playwright.ui.config.ts @@ -1,11 +1,12 @@ /** * `pnpm e2e:ui`: Chromium against a Vite dev server with no backend, on a * loopback port of its own (never the owner's `pnpm dev` on 5173, never - * reused): the Dialog test page and the local tool. docs/development/BROWSER_TESTS.md. + * reused): the Dialog test page, the local tool and the canvas click proof (also on + * Firefox and WebKit when installed). docs/development/BROWSER_TESTS.md. */ import { defineConfig } from '@playwright/test' import type { GuardOptions } from './support/browser' -import { PROJECTS } from './support/browser' +import { CLICK_PROJECTS, PROJECTS } from './support/browser' const ORIGIN = 'http://127.0.0.1:5191' @@ -27,7 +28,7 @@ export default defineConfig({ trace: 'retain-on-failure', screenshot: 'only-on-failure', }, - projects: PROJECTS, + projects: [...PROJECTS, ...CLICK_PROJECTS], webServer: { command: 'node_modules/.bin/vite --host 127.0.0.1 --port 5191 --strictPort', cwd: '..', diff --git a/apps/app/e2e/support/browser.ts b/apps/app/e2e/support/browser.ts index 674c4182..fa5e1825 100644 --- a/apps/app/e2e/support/browser.ts +++ b/apps/app/e2e/support/browser.ts @@ -3,11 +3,14 @@ * the two Chromium projects, the request guard every test runs under, the axe * gate, and the focus and layout probes. */ +import { existsSync } from 'node:fs' import AxeBuilder from '@axe-core/playwright' import { devices, expect, + firefox, test as base, + webkit, type Page, type Project, } from '@playwright/test' @@ -37,6 +40,51 @@ export const PROJECTS: Project[] = [ }, ] +/** + * The canvas click proof (V1-2.2, e2e/ui/canvas-clicks.spec.ts) also runs on Firefox and + * WebKit, desktop, and on the WebKit phone, when the pinned engine is installed + * (`playwright install firefox webkit`, no sudo, never `--with-deps`). A missing engine is + * named in the run's output, never passed silently. + */ +const CANVAS_CLICKS = /canvas-clicks\.spec\.ts$/ + +function installed(name: string, executable: string): boolean { + const present = existsSync(executable) + if (!present) console.warn(`canvas clicks: ${name} is not installed, its projects do not run`) + return present +} + +export const CLICK_PROJECTS: Project[] = [ + ...(installed('firefox', firefox.executablePath()) + ? [ + { + name: 'firefox-desktop', + testMatch: CANVAS_CLICKS, + grepInvert: /@phone/, + use: { ...devices['Desktop Firefox'], viewport: { width: 1280, height: 800 } }, + }, + ] + : []), + ...(installed('webkit', webkit.executablePath()) + ? [ + { + name: 'webkit-desktop', + testMatch: CANVAS_CLICKS, + grepInvert: /@phone/, + use: { ...devices['Desktop Safari'], viewport: { width: 1280, height: 800 } }, + }, + { + name: 'webkit-375', + testMatch: CANVAS_CLICKS, + use: { + ...devices['iPhone SE'], + viewport: { width: 375, height: 667 }, + }, + }, + ] + : []), +] + export interface GuardOptions { /** Origins the page may reach; every other request is aborted and fails the test. */ allowedOrigins: string[] diff --git a/apps/app/e2e/tsconfig.json b/apps/app/e2e/tsconfig.json index ea6716e8..3bae59f8 100644 --- a/apps/app/e2e/tsconfig.json +++ b/apps/app/e2e/tsconfig.json @@ -7,5 +7,5 @@ "@/*": ["src/*"] } }, - "include": ["."] + "include": [".", "../src/sheets/virtual-sheet.d.ts"] } diff --git a/apps/app/e2e/ui/canvas-clicks.spec.ts b/apps/app/e2e/ui/canvas-clicks.spec.ts new file mode 100644 index 00000000..848f59d2 --- /dev/null +++ b/apps/app/e2e/ui/canvas-clicks.spec.ts @@ -0,0 +1,133 @@ +import { expect, test } from '../support/browser' +import type { Page } from '@playwright/test' + +// V1-2.2 owner brief 2026-10-30, defect 2: a click on the editor canvas records the marker +// under the pointer, never another one, whatever stroke the drawing's root sets. Real +// clicks (taps on the phone project) on the bundled equine sheet in AnatomyCanvas +// (e2e/harness/canvas.tsx); run on Chromium, Firefox and WebKit when installed. + +/** + * The points of the equine main view whose visible disc no other marker covers, in document + * order. The three vertebral junctions sit on the edge of a zone painted after them: part of + * their disc records the zone (pre-existing, owner decision, see the fixme below). + */ +const POINTS = [ + 'hind-fetlock', + 'hock', + 'stifle', + 'hip', + 'sacroiliac', + 'shoulder', + 'elbow', + 'carpus', + 'fore-fetlock', + 'fore-sesamoids', +] +const JUNCTIONS = ['l6-s1', 't18-l1', 'c7-t1'] +const DRAWINGS = ['plain', 'giant-stroke', 'invisible-stroke', 'hidden-stroke'] + +type Point = { x: number; y: number } + +async function open(page: Page, drawing: string) { + await page.goto(`/e2e/harness/canvas.html?drawing=${drawing}`) + await expect( + page.locator('[data-testid="anatomy-canvas"] [data-anno-id="hock"]').first(), + ).toBeAttached() +} + +/** The centre of a marker's visible shape on screen (a point's twin shares its hitbox's). */ +async function centreOf(page: Page, id: string): Promise { + const box = await page + .locator(`[data-testid="anatomy-canvas"] [data-anno-id="${id}"]`) + .last() + .boundingBox() + if (!box) throw new Error(`${id} has no box`) + return { x: box.x + box.width / 2, y: box.y + box.height / 2 } +} + +async function press(page: Page, at: Point, touch: boolean) { + if (touch) await page.touchscreen.tap(at.x, at.y) + else await page.mouse.click(at.x, at.y) +} + +/** The ids recorded by the clicks so far. */ +async function recorded(page: Page): Promise { + const text = (await page.getByTestId('clicks').textContent()) ?? '' + return text.split(' ').filter(Boolean) +} + +async function clickRecords(page: Page, at: Point, touch = false) { + const before = (await recorded(page)).length + await press(page, at, touch) + // A click that records nothing leaves the list as it was; wait out the handler. + await page.waitForTimeout(50) + return (await recorded(page)).slice(before) +} + +test.describe('canvas clicks', () => { + for (const drawing of DRAWINGS) { + test(`a click on the hock records the hock (${drawing})`, async ({ page }, info) => { + await open(page, drawing) + const touch = info.project.use.hasTouch === true + expect(await clickRecords(page, await centreOf(page, 'hock'), touch)).toEqual(['hock']) + }) + + test(`every point clear of the zones records itself (${drawing})`, async ({ page }) => { + await open(page, drawing) + for (const id of POINTS) { + expect(await clickRecords(page, await centreOf(page, id)), id).toEqual([id]) + } + }) + + test(`a click on the drawing away from the markers records nothing (${drawing})`, async ({ + page, + }) => { + await open(page, drawing) + const box = await page.getByTestId('anatomy-canvas').boundingBox() + if (!box) throw new Error('no canvas') + // The top left corner and the middle of the belly hold no marker. + for (const [fx, fy] of [ + [0.03, 0.05], + [0.5, 0.55], + ] as const) { + const at = { x: box.x + box.width * fx, y: box.y + box.height * fy } + expect(await clickRecords(page, at), `${fx},${fy}`).toEqual([]) + } + }) + } + + test('two close points each record themselves, their shared edge goes to the later one', async ({ + page, + }) => { + await open(page, 'giant-stroke') + const fetlock = await centreOf(page, 'fore-fetlock') + const sesamoids = await centreOf(page, 'fore-sesamoids') + expect(await clickRecords(page, fetlock)).toEqual(['fore-fetlock']) + expect(await clickRecords(page, sesamoids)).toEqual(['fore-sesamoids']) + // Halfway, outside both visible discs and inside both hitboxes: document order, the + // later marker is on top. One id, never two. + const half = { x: (fetlock.x + sesamoids.x) / 2, y: (fetlock.y + sesamoids.y) / 2 } + expect(await clickRecords(page, half)).toEqual(['fore-sesamoids']) + }) + + test('a click on a vertebral junction records the junction', async ({ page }) => { + test.fixme( + true, + 'V1-2.2 finding: the zones are painted and hit after the points; c7-t1 records « thoracic » at its centre in Firefox and WebKit, and up to half of each junction disc records a zone in every engine (owner decision on the capture order)', + ) + await open(page, 'plain') + for (const id of JUNCTIONS) { + expect(await clickRecords(page, await centreOf(page, id)), id).toEqual([id]) + } + }) + + // @phone: the desktop projects leave it out (grepInvert), the touch projects run it. + test('a tap on the hock records the hock @phone', async ({ page }) => { + for (const drawing of DRAWINGS) { + await open(page, drawing) + expect(await clickRecords(page, await centreOf(page, 'hock'), true), drawing).toEqual([ + 'hock', + ]) + } + }) +}) diff --git a/apps/app/tests/helpers/svgTree.ts b/apps/app/tests/helpers/svgTree.ts index 990e7e0f..acf678c7 100644 --- a/apps/app/tests/helpers/svgTree.ts +++ b/apps/app/tests/helpers/svgTree.ts @@ -126,3 +126,49 @@ export function withIdsScopedPerView(tree: unknown, viewId: string): unknown { visit(copy) return copy } + +const HITBOX_DECLARED = { stroke: 'none', 'pointer-events': 'visibleFill' } + +/** A point hitbox of the R3 layer: a circle capturing on `all` with no stroke of its own. */ +function isR3Hitbox(node: unknown): node is { name: string; attrs: Record } { + const n = node as { name?: string; attrs?: Record } + return n.name === 'circle' && n.attrs?.['pointer-events'] === 'all' && !('stroke' in n.attrs) +} + +/** + * Owner brief 2026-10-30 (V1-2.2, three MEDIUM): each point hitbox the composers draw declares + * `stroke="none"` and `pointer-events="visibleFill"`. Applied to a frozen layer (a deep copy). + * Mirrors `crates/core/tests/common/svg_tree.rs`. + */ +export function withDeclaredHitboxes(layer: unknown): unknown { + const copy = structuredClone(layer) as { children?: unknown[] } + for (const child of copy.children ?? []) { + if (isR3Hitbox(child)) Object.assign(child.attrs, HITBOX_DECLARED) + } + return copy +} + +/** + * Owner brief 2026-10-30 (V1-2.2, three MEDIUM): the composition root is the engine's. Applied + * to a frozen canvas tree (a deep copy): the root keeps its namespaces and `viewBox`; its other + * attributes and every child before the layer go into a `` of the drawing; the layer's + * hitboxes are declared (`withDeclaredHitboxes`). Mirrors `crates/core/tests/common/svg_tree.rs`. + */ +export function withIsolatedLayer(tree: unknown): unknown { + const root = structuredClone(tree) as { + ns: string + attrs: Record + children: unknown[] + } + const layer = root.children.pop() + const kept: Record = {} + const moved: Record = {} + for (const [name, value] of Object.entries(root.attrs)) { + if (name === 'xmlns' || name === 'xmlns:xlink' || name === 'viewBox') kept[name] = value + else moved[name] = value + } + const group = { ns: root.ns, name: 'g', attrs: moved, children: root.children } + root.attrs = kept + root.children = [group, withDeclaredHitboxes(layer)] + return root +} diff --git a/apps/app/tests/unit/canvas.trees.test.tsx b/apps/app/tests/unit/canvas.trees.test.tsx index 93426a8d..8482cd4e 100644 --- a/apps/app/tests/unit/canvas.trees.test.tsx +++ b/apps/app/tests/unit/canvas.trees.test.tsx @@ -21,7 +21,9 @@ import { import { checkR3Golden, treeOf, + withDeclaredHitboxes, withIdsScopedPerView, + withIsolatedLayer, withTriggerNamesPerLanguage, type TreeNode, } from '../helpers/svgTree' @@ -82,9 +84,10 @@ describe.each(VIEWS)('the %s canvas', (viewId) => { it('builds the frozen tree with no state', () => { const build = buildViewSvg(sheet, viewId) if (!build.ok) throw new Error(`canvas ${viewId}: ${build.failure}`) - // and the owner's decision 2026-10-29: the drawing's ids scoped to the view + // and the owner's decision 2026-10-29: the drawing's ids scoped to the view; the brief + // 2026-10-30: the composition root is the engine's, the hitboxes declared checkR3Golden(`canvas.${viewId}.json`, treeOf(build.svg), (frozen) => - withIdsScopedPerView(declared(frozen), viewId), + withIsolatedLayer(withIdsScopedPerView(declared(frozen), viewId)), ) }) @@ -94,6 +97,13 @@ describe.each(VIEWS)('the %s canvas', (viewId) => { layers[name] = await mountedLayer(viewId, states) } expect(Object.keys(layers).length).toBeGreaterThan(8) - checkR3Golden(`canvas.${viewId}.layers.json`, layers, declared) + checkR3Golden(`canvas.${viewId}.layers.json`, layers, (frozen) => + Object.fromEntries( + Object.entries(declared(frozen) as Record).map(([name, layer]) => [ + name, + withDeclaredHitboxes(layer), + ]), + ), + ) }) }) diff --git a/crates/core/src/anatomy/compose.rs b/crates/core/src/anatomy/compose.rs index 457f4b0a..ca990c72 100644 --- a/crates/core/src/anatomy/compose.rs +++ b/crates/core/src/anatomy/compose.rs @@ -1,9 +1,9 @@ //! Composition of one view (`docs/ANNOTATION-RENDERING.md`): the sanitised drawing framed on //! the view, with its annotation layer last. Two forms, as the TypeScript has them: the -//! editor canvas (`apps/app/src/anatomy/drawing.ts`: a fresh root, `0 0 100 100` when no box -//! is known, the interactive layer) and the PDF highlight (`packages/anatomy/src/render/ -//! compose.ts`: the asset's root framed in place, the selected markers only, recoloured, the -//! halo filter on request). Both take a sanitised tree, never text. +//! editor canvas (`apps/app/src/anatomy/drawing.ts`: `0 0 100 100` when no frame is known, the +//! interactive layer) and the PDF highlight (`packages/anatomy/src/render/compose.ts`: no +//! `viewBox` when no frame is known, the selected markers only, recoloured, the halo filter on +//! request). Both take a sanitised tree, never text. //! //! The canvas is inlined into the page, where `#id` resolves against the whole document: its //! ids and the references to them are scoped to the view (`fv..`, owner decision @@ -13,19 +13,23 @@ //! own and keeps the drawing's ids, so it never holds one the composition writes //! (`svg::refs::RESERVED_IDS`, the halo filter): the reader refuses such a drawing and both //! composers refuse such a tree. -//! Both forms append the marker layer as the root's last child, so the root never hides it: a -//! root `visibility` other than `visible` is refused by the reader and by both composers. -//! Both frame the view on `frame::view_frame` (the view's box, else the drawing's `viewBox` read -//! as a browser reads it), the frame the verdict and the preview measure the annotations against -//! (V1-2.2 owner brief 2026-10-30, defect 3); the canvas falls back to `0 0 100 100`, the PDF -//! view to no `viewBox`. The drawing's `preserveAspectRatio` is dropped: the default -//! `xMidYMid meet` shows the whole frame whatever the box (a `slice` would crop it where the -//! raster's aspect is clamped or the canvas box is not the frame's). +//! +//! The composition root is the engine's (V1-2.2 owner brief 2026-10-30): the namespaces and the +//! frame only. The frame is `frame::view_frame` (the view's box, else the drawing's `viewBox` read +//! as a browser reads it), the one the verdict and the preview measure the annotations against; +//! with no `preserveAspectRatio` the default `xMidYMid meet` shows the whole frame whatever the +//! box. The drawing's root becomes a +//! `` keeping its other attributes and its children, and the marker layer (and the PDF's halo +//! filter, in a `` of the engine) are appended as that group's siblings: no property the +//! drawing sets, inherited (`stroke-width`, `stroke-opacity`, `stroke-dasharray`, `fill-rule`, +//! `visibility`…) or acting on a whole group (`opacity`, `display`), reaches a marker or the +//! halo. A root `visibility` other than `visible` stays refused by the reader and by both +//! composers (accepted fix of 2026-10-30). use std::collections::HashSet; use super::frame::view_frame; -use super::layer::{LayerError, find_view, render_layer}; +use super::layer::{LayerError, find_view, render_composed_layer}; pub use super::svg::refs::HALO_FILTER_ID; use super::svg::refs::holds_reserved_id; use super::svg::sanitize::check_root_visibility; @@ -54,8 +58,9 @@ pub enum ComposeError { /// composes it. Fail-closed: the reader refuses it (`reserved_id`), so only a tree that did /// not come out of `read_svg` reaches it, a composed view given back included. ReservedId, - /// The drawing's root carries a `visibility` other than `visible`, which the marker layer - /// would inherit. Fail-closed: the reader refuses it (`root_visibility`). + /// The drawing's root carries a `visibility` other than `visible` (the marker layer inherited + /// it before the root became the engine's). Fail-closed: the reader refuses it + /// (`root_visibility`). RootVisibility, } @@ -98,32 +103,62 @@ pub fn compose_canvas( if check_root_visibility(asset).is_err() { return Err(ComposeError::RootVisibility); } - let mut root = Element { - qname: "svg".to_owned(), - namespace: asset.namespace.clone(), - attrs: asset - .attrs - .iter() - .filter(|a| !matches!(a.qname.as_str(), "width" | "height" | "preserveAspectRatio")) - .cloned() - .collect(), - children: asset.children.clone(), - }; let view_box = view_frame(view, asset).map_or_else( || CANVAS_FALLBACK_VIEW_BOX.to_owned(), |frame| frame.view_box(), ); - root.set_attr("viewBox", view_box); + let mut root = isolated(asset.clone(), Some(view_box)); let scope = id_scope(view_id); scope_ids(&mut root, &scope); if !references_scoped(&root, &scope) { return Err(ComposeError::UnscopedReference); } - let layer = render_layer(document, view_id, &HashSet::new())?; + let layer = render_composed_layer(document, view_id, &HashSet::new())?; root.children.push(Node::Element(checked(layer)?)); Ok(root) } +/// Root attributes with no meaning on a ``: the frame is the engine's, the size is the +/// page's or the raster's. +const ROOT_ONLY: [&str; 7] = [ + "viewBox", + "preserveAspectRatio", + "version", + "width", + "height", + "x", + "y", +]; + +/// The composition root framed on `view_box`, holding the drawing as its one child: a `` +/// with the drawing root's attributes (namespace declarations and `ROOT_ONLY` aside) and its +/// children. The caller appends the engine's elements after it. +fn isolated(asset: Element, view_box: Option) -> Element { + let (namespaces, attrs): (Vec<_>, Vec<_>) = asset + .attrs + .into_iter() + .partition(|a| a.qname == "xmlns" || a.qname == "xmlns:xlink"); + let drawing = Element { + qname: "g".to_owned(), + namespace: asset.namespace.clone(), + attrs: attrs + .into_iter() + .filter(|a| !ROOT_ONLY.contains(&a.qname.as_str())) + .collect(), + children: asset.children, + }; + let mut root = Element { + qname: "svg".to_owned(), + namespace: asset.namespace, + attrs: namespaces, + children: vec![Node::Element(drawing)], + }; + if let Some(view_box) = view_box { + root.set_attr("viewBox", view_box); + } + root +} + /// The prefix of a view's ids in its canvas. Stable ids hold no `.`, so the scope of one view /// is never the start of another's, and no page id starts with `fv.`. pub fn id_scope(view_id: &str) -> String { @@ -180,7 +215,7 @@ fn scope_ids(element: &mut Element, scope: &str) { pub fn compose_highlight( document: &AnatomicalSheetDocument, view_id: &str, - mut asset: Element, + asset: Element, annotation_ids: &HashSet<&str>, halo: bool, ) -> Result { @@ -191,20 +226,16 @@ pub fn compose_highlight( if check_root_visibility(&asset).is_err() { return Err(ComposeError::RootVisibility); } - match view_frame(view, &asset) { - Some(frame) => asset.set_attr("viewBox", frame.view_box()), - None => asset.remove_attr("viewBox"), - } - asset.remove_attr("width"); - asset.remove_attr("height"); - asset.remove_attr("preserveAspectRatio"); + let view_box = view_frame(view, &asset).map(|frame| frame.view_box()); + let mut root = isolated(asset, view_box); if halo { - add_halo_filter(&mut asset); + let defs = Element::svg("defs", Vec::new(), vec![Node::Element(halo_filter())]); + root.children.push(Node::Element(defs)); } - let layer = render_layer(document, view_id, &HashSet::new())?; + let layer = render_composed_layer(document, view_id, &HashSet::new())?; let layer = highlight_layer(layer, annotation_ids, halo); - asset.children.push(Node::Element(checked(layer)?)); - Ok(asset) + root.children.push(Node::Element(checked(layer)?)); + Ok(root) } /// The layer reduced to the selected annotations, recoloured, every `data-*` dropped. @@ -235,31 +266,6 @@ fn highlight_element(mut element: Element, halo: bool) -> Element { element } -/// The halo filter in the first `` of the drawing, else in a new `` placed first. -fn add_halo_filter(root: &mut Element) { - if !append_to_first_defs(root) { - let defs = Element::svg("defs", Vec::new(), vec![Node::Element(halo_filter())]); - root.children.insert(0, Node::Element(defs)); - } -} - -/// Appends the halo to the first `` below `element` (document order). -fn append_to_first_defs(element: &mut Element) -> bool { - for child in &mut element.children { - let Node::Element(child) = child else { - continue; - }; - if child.qname == "defs" { - child.children.push(Node::Element(halo_filter())); - return true; - } - if append_to_first_defs(child) { - return true; - } - } - false -} - fn halo_filter() -> Element { let blur = |std: &str, result: &str| { Node::Element(Element::svg( diff --git a/crates/core/src/anatomy/layer.rs b/crates/core/src/anatomy/layer.rs index 407efeb1..0e4bb774 100644 --- a/crates/core/src/anatomy/layer.rs +++ b/crates/core/src/anatomy/layer.rs @@ -27,14 +27,38 @@ pub fn find_view<'a>( } /// `renderAnnotationLayer({ document, viewId, states })`: `states` holds the ids marked -/// `data-state="current"`. +/// `data-state="current"`. The R3 tree, kept for the seed review drawings +/// (`curation::draft::app_review`); the composers draw `render_composed_layer`. pub fn render_layer( document: &AnatomicalSheetDocument, view_id: &str, states: &HashSet<&str>, +) -> Result { + layer(document, view_id, states, false) +} + +/// The layer the composers draw (V1-2.2 owner brief 2026-10-30): the R3 tree with each point +/// hitbox declaring its paint and its capture rule, `stroke="none"` and +/// `pointer-events="visibleFill"`, so its clickable area is its circle whatever stroke the page +/// or a drawing would give it (under `pointer-events="all"` a stroke widens the hit area even +/// when nothing paints it). The zones and the trigger already declare theirs. +pub fn render_composed_layer( + document: &AnatomicalSheetDocument, + view_id: &str, + states: &HashSet<&str>, +) -> Result { + layer(document, view_id, states, true) +} + +fn layer( + document: &AnatomicalSheetDocument, + view_id: &str, + states: &HashSet<&str>, + declared_hitbox: bool, ) -> Result { let view = find_view(document, view_id).ok_or(LayerError::UnknownView)?; let context = Context { + declared_hitbox, twin_opacity: if view.is_main() { "0.65" } else { "0.5" }, categories: document .categories @@ -59,6 +83,8 @@ pub fn render_layer( } struct Context<'a> { + /// The hitbox declares `stroke="none"` and captures on its circle only (composed form). + declared_hitbox: bool, twin_opacity: &'static str, /// Last duplicate wins, as a JavaScript `Map` built from the list. categories: HashMap<&'a str, Option<&'a str>>, @@ -154,9 +180,14 @@ impl Context<'_> { ("cy", js_number(cy)), ("r", js_number(r)), ("fill", "transparent".to_owned()), - ("pointer-events", "all".to_owned()), - ("style", "cursor:pointer".to_owned()), ]; + if self.declared_hitbox { + hitbox.push(("stroke", "none".to_owned())); + hitbox.push(("pointer-events", "visibleFill".to_owned())); + } else { + hitbox.push(("pointer-events", "all".to_owned())); + } + hitbox.push(("style", "cursor:pointer".to_owned())); hitbox.extend(data.iter().cloned()); let mut visible: Attrs = vec![ ("cx", js_number(cx)), diff --git a/crates/core/src/anatomy/svg/mod.rs b/crates/core/src/anatomy/svg/mod.rs index f499619c..85bea934 100644 --- a/crates/core/src/anatomy/svg/mod.rs +++ b/crates/core/src/anatomy/svg/mod.rs @@ -14,7 +14,7 @@ pub use tree::{Element, Node, SvgRejection}; /// Bounds, parses, sanitises and checks the references of an SVG text: no cycle, within the /// expansion budget, each naming an id the drawing defines; no id the composition writes and -/// no root `visibility` the marker layer would inherit. +/// no root `visibility` other than `visible`. pub fn read_svg(text: &str) -> Result { let root = tree::parse_svg(text)?; let sanitized = sanitize::sanitize(root)?; diff --git a/crates/core/src/anatomy/svg/refs.rs b/crates/core/src/anatomy/svg/refs.rs index 95f32486..dc99a3dc 100644 --- a/crates/core/src/anatomy/svg/refs.rs +++ b/crates/core/src/anatomy/svg/refs.rs @@ -18,8 +18,8 @@ use super::tree::{Element, Node, SvgRejection}; /// Expanded elements a drawing may instantiate (the product's drawing: a few thousand). pub const MAX_EXPANDED_ELEMENTS: u64 = 50_000; -/// The PDF highlight's filter (`compose::compose_highlight`), written into the drawing's own -/// document: the PDF view keeps the drawing's ids. +/// The PDF highlight's filter (`compose::compose_highlight`), written in an engine `` of +/// the composed document next to the drawing: the PDF view keeps the drawing's ids. pub const HALO_FILTER_ID: &str = "osteo-halo"; /// Every id the composition writes next to the drawing's ids. A drawing defining one would diff --git a/crates/core/src/anatomy/svg/sanitize.rs b/crates/core/src/anatomy/svg/sanitize.rs index b4cbd24f..dfde5883 100644 --- a/crates/core/src/anatomy/svg/sanitize.rs +++ b/crates/core/src/anatomy/svg/sanitize.rs @@ -44,7 +44,8 @@ const ALLOWED_ELEMENTS: [&str; 28] = [ "use", ]; -const ALLOWED_ATTRIBUTES: [&str; 77] = [ +/// Public for the marker isolation census (`tests/svg_marker_isolation.rs`). +pub const ALLOWED_ATTRIBUTES: [&str; 77] = [ "id", "class", "d", @@ -435,10 +436,10 @@ fn value_acceptable(qname: &str, value: &str) -> bool { } /// The root lets the engine's marker layer show: no `visibility`, or `visible` (CSS whitespace -/// and letter case aside). Both composers append the layer as the root's last child, so it -/// inherits the root's `visibility`, which the drawing's own children can set back to -/// `visible`: any other value, `hidden`, `collapse`, a CSS-wide keyword or an unreadable one, -/// is refused (V1-2.2 security review, owner brief 2026-10-30). The root's `style` and `class` +/// and letter case aside). Until the composition root became the engine's, the layer inherited +/// the root's `visibility`, which the drawing's own children can set back to `visible`: any +/// other value, `hidden`, `collapse`, a CSS-wide keyword or an unreadable one, stays refused +/// (V1-2.2 security review, owner brief 2026-10-30), the composers checking it too. The root's `style` and `class` /// are removed by `sanitize`, so this attribute is the one way left to set it. pub fn check_root_visibility(root: &Element) -> Result<(), SvgRejection> { let visible = root.attr("visibility").is_none_or(|value| { diff --git a/crates/core/src/anatomy/svg/tree.rs b/crates/core/src/anatomy/svg/tree.rs index 91c3886a..545943de 100644 --- a/crates/core/src/anatomy/svg/tree.rs +++ b/crates/core/src/anatomy/svg/tree.rs @@ -111,9 +111,9 @@ pub enum SvgRejection { /// An id the composition writes into the drawing's own document (`refs::RESERVED_IDS`): /// the drawing's element would stand in for the engine's (V1-2.2, owner brief 2026-10-30). ReservedId, - /// A `visibility` on the root other than `visible`: the engine's marker layer, appended as - /// the root's last child, inherits it, while the drawing's own children can set `visible` - /// back (V1-2.2 security review, owner brief 2026-10-30). + /// A `visibility` on the root other than `visible`: until the composition root became the + /// engine's, the marker layer inherited it while the drawing's own children set `visible` + /// back (V1-2.2 security review, owner brief 2026-10-30); kept as a reader rule. RootVisibility, } diff --git a/crates/core/src/curation/draft/app_review.rs b/crates/core/src/curation/draft/app_review.rs index bca78823..aaad0069 100644 --- a/crates/core/src/curation/draft/app_review.rs +++ b/crates/core/src/curation/draft/app_review.rs @@ -4,6 +4,11 @@ //! uses. Written under `draft/review/app-.svg` so the markers and the framing can be //! compared outside the browser. //! +//! Declared difference (V1-2.2, owner brief 2026-10-30): the application draws the drawing in a +//! group of its own under an engine root and declares each point hitbox's stroke and capture +//! (`compose`, `layer::render_composed_layer`); this review drawing keeps the R5 form, a seed +//! resource never regenerated without the owner. +//! //! Declared difference: the R3 owner decision (2026-10-15) gives a trigger without a name of //! its own the opened view's name in each language; the TypeScript renderer wrote the French //! name twice (`svg_compare::TriggerNames`). diff --git a/crates/core/tests/anatomy_canvas_op.rs b/crates/core/tests/anatomy_canvas_op.rs index 50e2799a..e9ad4063 100644 --- a/crates/core/tests/anatomy_canvas_op.rs +++ b/crates/core/tests/anatomy_canvas_op.rs @@ -5,7 +5,8 @@ mod common; use common::svg_tree::{ - tree_value, view_names, with_ids_scoped_per_view, with_trigger_names_per_language, + tree_value, view_names, with_ids_scoped_per_view, with_isolated_layer, + with_trigger_names_per_language, }; use faunosteo_core::anatomy::svg::tree::parse_svg; use faunosteo_core::domain::js::parse_json; @@ -44,6 +45,7 @@ fn golden(view: &str, sheet: &LoadedSheet) -> Value { let mut frozen: Value = serde_json::from_str(&text).unwrap(); with_trigger_names_per_language(&mut frozen, &view_names(&sheet.document)); with_ids_scoped_per_view(&mut frozen, view); + with_isolated_layer(&mut frozen); frozen } diff --git a/crates/core/tests/anatomy_compose.rs b/crates/core/tests/anatomy_compose.rs index 6809da5a..873a860d 100644 --- a/crates/core/tests/anatomy_compose.rs +++ b/crates/core/tests/anatomy_compose.rs @@ -12,7 +12,8 @@ mod common; use std::collections::HashSet; use common::svg_tree::{ - reread, tree_value, view_names, with_ids_scoped_per_view, with_trigger_names_per_language, + reread, tree_value, view_names, with_ids_scoped_per_view, with_isolated_layer, + with_trigger_names_per_language, }; use faunosteo_core::anatomy::compose::{ ComposeError, asset_id_of_view, compose_canvas, compose_highlight, @@ -96,6 +97,7 @@ fn every_highlighted_view_equals_the_engine_tree() { let label = format!("{} {} {view}", case["sheet"], case["observation"]["id"]); let mut frozen = expected(case, &oracle); with_trigger_names_per_language(&mut frozen, &view_names(document)); + with_isolated_layer(&mut frozen); assert_eq!(reread(&composed), frozen, "{label}"); } } @@ -109,6 +111,7 @@ fn canvas_golden(view: &str) -> Value { let mut frozen: Value = serde_json::from_str(&text).unwrap(); with_trigger_names_per_language(&mut frozen, &view_names(&draft())); with_ids_scoped_per_view(&mut frozen, view); + with_isolated_layer(&mut frozen); frozen } diff --git a/crates/core/tests/common/svg_tree.rs b/crates/core/tests/common/svg_tree.rs index b430111e..119647d8 100644 --- a/crates/core/tests/common/svg_tree.rs +++ b/crates/core/tests/common/svg_tree.rs @@ -101,3 +101,77 @@ pub fn view_names( .map(|v| (v.id().to_owned(), v.name().fr.clone(), v.name().en.clone())) .collect() } + +/// Owner brief 2026-10-30 (V1-2.2, three MEDIUM): the composition root is the engine's. Applied +/// to a frozen view tree before comparing, written apart from the core: the root keeps its +/// namespaces and `viewBox`; its other attributes and every child before the layer go into a +/// ``; the halo filter leaves the drawing for an engine `` placed before the layer; +/// each point hitbox (a circle capturing on `all` with no stroke of its own) declares +/// `stroke="none"` and `pointer-events="visibleFill"`. +pub fn with_isolated_layer(tree: &mut Value) { + let root = tree.as_object_mut().unwrap(); + let mut children = root["children"].as_array().unwrap().clone(); + let mut layer = children.pop().unwrap(); + let halo = take_halo(&mut children); + let attrs = root["attrs"].as_object().unwrap().clone(); + let (kept, moved): (Vec<_>, Vec<_>) = attrs + .into_iter() + .partition(|(name, _)| ["xmlns", "xmlns:xlink", "viewBox"].contains(&name.as_str())); + let group = json!({ + "ns": root["ns"], "name": "g", + "attrs": moved.into_iter().collect::>(), + "children": children, + }); + let mut out = vec![group]; + if let Some(halo) = halo { + out.push(json!({ "ns": SVG_NS, "name": "defs", "attrs": {}, "children": [halo] })); + } + for marker in layer["children"].as_array_mut().unwrap() { + let circle = marker["name"] == "circle"; + let attrs = marker["attrs"].as_object_mut().unwrap(); + let hitbox = circle + && attrs.get("pointer-events") == Some(&json!("all")) + && !attrs.contains_key("stroke"); + if hitbox { + attrs.insert("stroke".to_owned(), json!("none")); + attrs.insert("pointer-events".to_owned(), json!("visibleFill")); + } + } + out.push(layer); + root.insert( + "attrs".to_owned(), + Value::Object(kept.into_iter().collect()), + ); + root.insert("children".to_owned(), Value::Array(out)); +} + +/// Removes `filter#osteo-halo` from the frozen drawing (and the `` the engine created for +/// it alone, placed first), answering it. +fn take_halo(children: &mut Vec) -> Option { + let first_is_engine_defs = children.first().is_some_and(|c| { + c["name"] == "defs" + && c["children"] + .as_array() + .is_some_and(|k| k.len() == 1 && k[0]["attrs"]["id"] == "osteo-halo") + }); + if first_is_engine_defs { + return Some(children.remove(0)["children"][0].clone()); + } + for child in children.iter_mut() { + if let Some(found) = take_from(child) { + return Some(found); + } + } + None +} + +fn take_from(node: &mut Value) -> Option { + let kids = node.get_mut("children")?.as_array_mut()?; + if let Some(at) = kids + .iter() + .position(|k| k["name"] == "filter" && k["attrs"]["id"] == "osteo-halo") + { + return Some(kids.remove(at)); + } + kids.iter_mut().find_map(take_from) +} diff --git a/crates/core/tests/svg_marker_isolation.rs b/crates/core/tests/svg_marker_isolation.rs new file mode 100644 index 00000000..fc8096ca --- /dev/null +++ b/crates/core/tests/svg_marker_isolation.rs @@ -0,0 +1,302 @@ +//! V1-2.2 owner brief « arbitrages propriétaire sur les trois MEDIUM » (2026-10-30), defects 1 +//! and 2: nothing the drawing sets reaches the engine's markers. Until then both composers +//! appended the marker layer to the drawing's own root, so the root's presentation attributes +//! reached every marker: inherited ones (`stroke-opacity="0"` or `stroke-dasharray` erased the +//! zone outlines and the detail trigger, `stroke-width` widened the point hitbox until the last +//! one took 13 of the 19 equine clicks) and whole-group ones (`opacity`, `display`). The +//! composition root is now the engine's (namespaces and frame only), the drawing sits in a +//! group of its own, and the layer and the halo filter are that group's siblings. The point +//! hitbox declares its paint and its capture rule (`stroke="none"`, `pointer-events= +//! "visibleFill"`), so its clickable area is its circle, whatever the page or the drawing set. +#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)] + +mod common; + +use std::collections::HashSet; + +use common::sheet_readers::{OPEN, sheet}; +use faunosteo_core::anatomy::compose::{compose_canvas, compose_highlight}; +use faunosteo_core::anatomy::svg::{Element, read_svg, sanitize}; +use faunosteo_core::domain::sheet::AnatomicalSheetDocument; +use serde::Deserialize; + +/// The attributes the composition root may carry: namespaces and the frame. +const ROOT_ATTRIBUTES: [&str; 3] = ["xmlns", "xmlns:xlink", "viewBox"]; + +/// Every presentation attribute the reader keeps on a drawing's root, with a value that would +/// change a marker if it reached one (the reader removes `class`, `style`, `transform`, +/// `filter`, `mask` and `clip-path` from the root, and refuses a root `visibility` other than +/// `visible`). +const ROOT_PROPERTIES: [&str; 22] = [ + "stroke=\"#ff00ff\"", + "stroke-width=\"400\"", + "stroke-opacity=\"0\"", + "stroke-dasharray=\"0 1000\"", + "stroke-dashoffset=\"7\"", + "stroke-linecap=\"square\"", + "stroke-linejoin=\"miter\"", + "stroke-miterlimit=\"100\"", + "fill=\"none\"", + "fill-opacity=\"0\"", + "fill-rule=\"evenodd\"", + "opacity=\"0\"", + "display=\"none\"", + "visibility=\"visible\"", + "color=\"#00ff00\"", + "clip-rule=\"evenodd\"", + "color-interpolation-filters=\"sRGB\"", + "font-family=\"serif\"", + "font-size=\"90\"", + "font-weight=\"bold\"", + "systemLanguage=\"xx\"", + "id=\"drawing\"", +]; + +const BODY: &str = ""; + +fn rooted(attrs: &str) -> String { + let root = OPEN.replace("viewBox", &format!("{attrs} viewBox")); + format!("{root}{BODY}") +} + +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 `` whose children set `visible` back read +//! show. Both composers appended the marker layer as the root's last child, so the layer +//! inherited the root's `visibility` (the composition root is the engine's since the three-MEDIUM +//! brief, `svg_marker_isolation`); a drawing `` whose children set `visible` back read //! clean before and showed its drawing without a single marker (security review, MEDIUM). The //! reader refuses a root `visibility` other than `visible` (`root_visibility`); the cleaning, //! the preview, the verdict and the PDF snapshot gate answer it; both composers refuse such a @@ -189,12 +189,10 @@ fn equivalent_styles_never_hide_the_layer() { assert!(layer_shows(&canvas.unwrap()) && layer_shows(&highlight.unwrap())); } -/// The other root properties that reach the layer. Removed by the reader before V1-2.2: the -/// paint servers and effects (`filter`, `mask`, `clip-path`), `transform`, `class`, `style`. -/// Kept: `opacity` and `display` act on the whole root, drawing and markers alike (the -/// browser proofs of RUST.md §12.10 show both); `fill` and `fill-opacity` are set on every PDF -/// marker. The stroke properties no marker sets (`stroke-opacity`, `stroke-dasharray`, -/// `stroke-width` on the hitbox) are an open owner decision, not covered here. +/// The other root properties. Removed by the reader before V1-2.2: the paint servers and +/// effects (`filter`, `mask`, `clip-path`), `transform`, `class`, `style`. Kept: `opacity`, +/// `display` and the paint, which since the three-MEDIUM brief stay on the drawing's group and +/// never reach a marker (`svg_marker_isolation`); every PDF marker still sets its fill. #[test] fn other_root_properties_are_removed_or_act_on_the_whole_view() { for name in ["filter", "mask", "clip-path"] { diff --git a/docs/ANNOTATION-RENDERING.md b/docs/ANNOTATION-RENDERING.md index a18e9153..9c1439a0 100644 --- a/docs/ANNOTATION-RENDERING.md +++ b/docs/ANNOTATION-RENDERING.md @@ -23,7 +23,7 @@ trigger. | Annotation | Elements | |---|---| | `detail_trigger`, any geometry | one dashed shape: fill and stroke = the colour, `fill-opacity` 0.06, `stroke-width` 2, `stroke-dasharray` `8,4`, `pointer-events` all, `style` `cursor:pointer`, class `detail-zone` | -| `point` or `zone` with a circle | a transparent hitbox (the geometry's `r`, `fill` transparent, `pointer-events` all, `style` `cursor:pointer`) then a visible twin on top (radius `max(2, r − 12)`, the colour, `fill-opacity` 0.65 on the main view / 0.5 on a detail view, stroke `#000` 1.5, `pointer-events` none) | +| `point` or `zone` with a circle | a transparent hitbox (the geometry's `r`, `fill` transparent, `stroke` none, `pointer-events` visibleFill, `style` `cursor:pointer`; the R3 form kept for the seed review drawings has no `stroke` and `pointer-events` all) then a visible twin on top (radius `max(2, r − 12)`, the colour, `fill-opacity` 0.65 on the main view / 0.5 on a detail view, stroke `#000` 1.5, `pointer-events` none) | | `point` or `zone` with a polygon or a path | one filled shape: fill and stroke = the colour, `fill-opacity` 0.3, `stroke-width` 2, `pointer-events` all, `style` `cursor:pointer` | Annotations without geometry draw nothing. Annotations follow the document @@ -111,22 +111,23 @@ a pointer cursor and brightens on hover. The engine composes the observation's zones of one view: the markers of the other annotations are dropped (not hidden), every `data-*` attribute is removed, the kept elements get fill `#b85a3f` at 0.85 and, on the main view, -the `osteo-halo` filter (two Gaussian blurs merged with the source), added to -the first `` of the drawing or to a new `` placed first. The PDF +the `osteo-halo` filter (two Gaussian blurs merged with the source), in a +`` of the engine placed after the drawing's group, before the layer. The PDF view keeps the drawing's ids, so `osteo-halo` is reserved (V1-2.2, owner brief 2026-10-30): the reader refuses a drawing holding it in any letter case (`reserved_id`) and both composers refuse such a tree, so the halo the markers name is always the engine's. -Both forms append the layer as the root's last child, so it inherits the -root's `visibility`. A root `visibility` other than `visible` is refused by -the reader (`root_visibility`) and by both composers: a drawing could -otherwise hide every marker while its own children set `visible` back. The -root's `class`, `style`, `transform`, `filter`, `mask` and `clip-path` are -removed by the reader; `opacity` and `display` on the root act on the drawing -and the markers alike. Still open (RUST.md §12.10): `stroke-opacity`, -`stroke-dasharray` and `stroke-width` on the root reach the markers, which do -not set them (the frame of a view: see Views, RUST.md §12.11). +The composition root is the engine's (V1-2.2, owner brief 2026-10-30, RUST.md +§12.12): `xmlns`, `xmlns:xlink` and the frame only. The drawing's root becomes +a `` holding its other attributes and its children; the layer (and the +halo's ``) are that group's siblings, so no property the drawing sets, +inherited (`stroke-*`, `fill*`, `visibility`…) or acting on a whole group +(`opacity`, `display`), reaches a marker: a root `opacity="0"` or +`display="none"` hides the drawing alone. A root `visibility` other than +`visible` stays refused by the reader (`root_visibility`) and by both +composers. The R3 trees stay frozen; the tests apply this declared change +(`withIsolatedLayer`, `withDeclaredHitboxes`, `with_isolated_layer`). ## Checking the look diff --git a/docs/development/BROWSER_TESTS.md b/docs/development/BROWSER_TESTS.md index 2b1c9621..39c55c33 100644 --- a/docs/development/BROWSER_TESTS.md +++ b/docs/development/BROWSER_TESTS.md @@ -1,7 +1,9 @@ # Browser tests (Playwright and axe) Status: V1-1.3, 2026-10-25 (decision D14, `V1-1_OWNERS_ANIMALS.md` §12.5). -Chromium only until V1-5. The suites live in `apps/app/e2e`. +Chromium only until V1-5, except the canvas click proof (V1-2.2), which also +runs on Firefox and WebKit, desktop and the WebKit phone, when the pinned +engines are installed. The suites live in `apps/app/e2e`. ## 1. Suites @@ -110,7 +112,12 @@ suite needs Docker in the runner for the sandbox. ## 6. Limits -- Chromium only. Firefox, WebKit and the 412 × 915 viewport join at V1-5 +- Chromium only, but `e2e/ui/canvas-clicks.spec.ts` (V1-2.2: projects + `firefox-desktop`, `webkit-desktop`, `webkit-375`, added when + `playwright install firefox webkit` has put the pinned engines in the cache; + a missing one is named in the run's output and its projects do not run; + harness `e2e/harness/canvas.{html,tsx}`, dev server only). Firefox, WebKit + and the 412 × 915 viewport join every suite at V1-5 (contract §12.5). WebKit's system libraries may need `sudo` (owner action). Desktop WebKit is not iOS Safari: the owner's manual check on a real iPhone and on a computer over the LAN stays a validation criterion of every mobile diff --git a/docs/development/RUST.md b/docs/development/RUST.md index 6a0cf214..370e7b62 100644 --- a/docs/development/RUST.md +++ b/docs/development/RUST.md @@ -4134,7 +4134,9 @@ Chromium and WebKit 13 of the 19 equine markers send their click to the last hit (the equine main view) is framed by the drawing's root `viewBox`: shifting it and translating the drawing back leaves the horse pixel-identical and every marker outside the frame. The class fix for (1) and (2) is the engine's: the layer `` resets the inherited properties (`visibility`, `stroke-opacity`, `stroke-dasharray`, …) and the hitbox gets -`stroke="none"`; it changes the R3 highlight oracle and the R4 digests. (3) needs a document rule (annotations inside +`stroke="none"`; it changes the R3 highlight oracle and the R4 digests (corrected in §12.12, 2026-11-01: the R4 PDF +digests do not change; the R3 highlight oracle and canvas goldens compare under a declared transform, and only the R4.1 +real-raster manifest's call-1 `svgSha256` is edited). (3) needs a document rule (annotations inside their view's frame, in the verdict and the preview) or the document owning the main view's frame. Browser proof (equine main view, `hip` selected, halo on; pixels that differ from the same SVG without its layer, so 0 @@ -4198,3 +4200,69 @@ Oracles: none changed by this rule; the R3 canvas and highlight trees, the R4 di frozen (no committed drawing carries a `preserveAspectRatio` or a `viewBox` in another spelling). Module: 560 377 → 572 993 B gzip -9 (+12 616 B, the curve and arc measure), 1 515 246 → 1 544 834 B raw; Node's gzip 582 919 B (budget 600 000). + +### 12.12 Marker isolation and the hitbox capture (owner, 2026-10-30, defects 1 and 2) + +Brief « V1-2.2 : arbitrages propriétaire sur les trois MEDIUM », points 1 and 2 (open items (1) and (2) of §12.10). A +structural fix in the composition, common to both forms, not a list of refused attributes. + +| Point | Built | Where | +|---|---|---| +| Composition root | the engine's own ``: `xmlns`, `xmlns:xlink`, the frame (§12.11). The drawing's root becomes a `` holding its other attributes (`viewBox`, `preserveAspectRatio`, `version`, `width`, `height`, `x`, `y` dropped) and its children; the marker layer, and in the PDF view an engine `` holding the halo filter, are that group's siblings | `anatomy/compose.rs` (`isolated`) | +| Layer | the composers draw `render_composed_layer`: the R3 tree with each point hitbox declaring `stroke="none"` and `pointer-events="visibleFill"` (its clickable area is its circle: under `all` a stroke widens the hit area even unpainted); the zones and the trigger already declare their stroke width; the R3 `render_layer` stays for the seed review drawings, unchanged | `anatomy/layer.rs` | +| Kept | the reader rules of §12.9 and §12.10 (`reserved_id`, `root_visibility`) and both composers' fail-closed checks | | + +What reached a marker before, and why the structure ends it: inherited properties (`stroke`, `stroke-width`, +`stroke-opacity`, `stroke-dasharray`, `stroke-dashoffset`, `stroke-linecap`, `stroke-linejoin`, `stroke-miterlimit`, +`fill`, `fill-opacity`, `fill-rule`, `visibility`, `color`, `clip-rule`, `color-interpolation-filters`, the font +properties) pass from an ancestor to a child, which a child's own attribute overrides only for the properties it sets; +`opacity`, `display` and the conditional `systemLanguage` act on the element and its whole subtree, which no child can +undo. The reader already removes the root's `class`, `style`, `transform`, `filter`, `mask` and `clip-path`, refuses a +root `visibility` other than `visible`, keeps no `pointer-events` or `cursor` attribute and no `