fix(anatomy): V1-2.2 marker layer and halo outside the drawing's group
Owner-approved lot B (brief 2026-11-01). The composition root is the engine's (namespaces and frame); the drawing's root becomes a group and the marker layer and halo are its siblings, so no root property reaches a marker. Point hitboxes declare stroke none and visibleFill. Census over the reader's whole allowlist; R3 references compared under the declared transform; click proofs in three engines.
This commit is contained in:
1 parent
f1bb19b30b
commit
4f52f5e1c4
23 files changed
+933
-112
No files matched your search
@@ -0,0 +1,12 @@
|
||||
<!doctype html>
|
||||
<html lang="fr">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Canvas harness</title>
|
||||
</head>
|
||||
<body>
|
||||
<div id="root"></div>
|
||||
<script type="module" src="./canvas.tsx"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -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<string, string> = {
|
||||
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('<svg ', `<svg ${rootAttrs} `),
|
||||
]),
|
||||
)
|
||||
return { ...sheet, assets }
|
||||
},
|
||||
})
|
||||
|
||||
function Harness() {
|
||||
const sheet = useSheet('equine')
|
||||
const [clicks, setClicks] = useState<string[]>([])
|
||||
return (
|
||||
<main className="p-4">
|
||||
<h1 className="text-xl font-semibold">Canvas harness</h1>
|
||||
{/* A fixed height: the canvas never moves when the first click is listed. */}
|
||||
<output data-testid="clicks" className="block h-6 overflow-hidden">
|
||||
{clicks.join(' ')}
|
||||
</output>
|
||||
<div style={{ width: 'min(1000px, 100%)', aspectRatio: '2073.4 / 1629.4' }}>
|
||||
{sheet.status === 'ready' && (
|
||||
<AnatomyCanvas
|
||||
index={sheet.index}
|
||||
viewId={viewId}
|
||||
states={new Map()}
|
||||
onZoneClick={(id) => setClicks((all) => [...all, id])}
|
||||
/>
|
||||
)}
|
||||
</div>
|
||||
</main>
|
||||
)
|
||||
}
|
||||
|
||||
createRoot(document.getElementById('root') as HTMLElement).render(
|
||||
<StrictMode>
|
||||
<Harness />
|
||||
</StrictMode>,
|
||||
)
|
||||
@@ -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<GuardOptions>({
|
||||
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: '..',
|
||||
|
||||
@@ -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[]
|
||||
|
||||
@@ -7,5 +7,5 @@
|
||||
"@/*": ["src/*"]
|
||||
}
|
||||
},
|
||||
"include": ["."]
|
||||
"include": [".", "../src/sheets/virtual-sheet.d.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<Point> {
|
||||
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<string[]> {
|
||||
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',
|
||||
])
|
||||
}
|
||||
})
|
||||
})
|
||||
@@ -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<string, string> } {
|
||||
const n = node as { name?: string; attrs?: Record<string, string> }
|
||||
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 `<g>` 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<string, string>
|
||||
children: unknown[]
|
||||
}
|
||||
const layer = root.children.pop()
|
||||
const kept: Record<string, string> = {}
|
||||
const moved: Record<string, string> = {}
|
||||
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
|
||||
}
|
||||
@@ -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<string, unknown>).map(([name, layer]) => [
|
||||
name,
|
||||
withDeclaredHitboxes(layer),
|
||||
]),
|
||||
),
|
||||
)
|
||||
})
|
||||
})
|
||||
@@ -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.<view id>.<id>`, 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
|
||||
//! `<g>` keeping its other attributes and its children, and the marker layer (and the PDF's halo
|
||||
//! filter, in a `<defs>` 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 `<g>`: 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 `<g>`
|
||||
/// 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<String>) -> 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<Element, ComposeError> {
|
||||
@@ -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 `<defs>` of the drawing, else in a new `<defs>` 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 `<defs>` 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(
|
||||
|
||||
@@ -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<Element, LayerError> {
|
||||
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<Element, LayerError> {
|
||||
layer(document, view_id, states, true)
|
||||
}
|
||||
|
||||
fn layer(
|
||||
document: &AnatomicalSheetDocument,
|
||||
view_id: &str,
|
||||
states: &HashSet<&str>,
|
||||
declared_hitbox: bool,
|
||||
) -> Result<Element, LayerError> {
|
||||
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)),
|
||||
|
||||
@@ -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<Sanitized, SvgRejection> {
|
||||
let root = tree::parse_svg(text)?;
|
||||
let sanitized = sanitize::sanitize(root)?;
|
||||
|
||||
@@ -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 `<defs>` 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
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
|
||||
@@ -4,6 +4,11 @@
|
||||
//! uses. Written under `draft/review/app-<view>.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`).
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
/// `<g>`; the halo filter leaves the drawing for an engine `<defs>` 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::<serde_json::Map<_, _>>(),
|
||||
"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 `<defs>` the engine created for
|
||||
/// it alone, placed first), answering it.
|
||||
fn take_halo(children: &mut Vec<Value>) -> Option<Value> {
|
||||
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<Value> {
|
||||
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)
|
||||
}
|
||||
@@ -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 = "<g><path d=\"M0 0h10v10z\"/></g>";
|
||||
|
||||
fn rooted(attrs: &str) -> String {
|
||||
let root = OPEN.replace("viewBox", &format!("{attrs} viewBox"));
|
||||
format!("{root}{BODY}</svg>")
|
||||
}
|
||||
|
||||
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::<serde_json::Value>(&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 `<defs>`) 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<String> = 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!("<g {attrs}>{BODY}</g>"));
|
||||
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!(
|
||||
"<g style=\"{style}\">{BODY}<rect width=\"9\" height=\"9\" style=\"{style}\"/></g>"
|
||||
);
|
||||
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}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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 `<svg visibility="hidden">` 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 `<svg visibility="hidden">` 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"] {
|
||||
|
||||
@@ -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 `<defs>` of the drawing or to a new `<defs>` placed first. The PDF
|
||||
the `osteo-halo` filter (two Gaussian blurs merged with the source), in a
|
||||
`<defs>` 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 `<g>` holding its other attributes and its children; the layer (and the
|
||||
halo's `<defs>`) 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
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
`<g>` 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 `<svg>`: `xmlns`, `xmlns:xlink`, the frame (§12.11). The drawing's root becomes a `<g>` 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 `<defs>` 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 `<style>` (a descendant's
|
||||
`style` may still set them, or any CSS property without a function call: it acts on the drawing only). With the layer a
|
||||
sibling of the drawing, its only ancestor is the engine's root (and, in the canvas, the page, whose stylesheet is the
|
||||
application's). Consequence for drawings: a root `opacity="0"` or `display="none"` now hides the drawing alone, in every
|
||||
engine and both forms (before: the whole view, or nothing, depending on the engine and the form).
|
||||
|
||||
Proofs: `svg_marker_isolation` (5, all red on `958228a`): 22 root properties one by one and all at once never on the
|
||||
layer's ancestors, the drawing keeping them on its group, in both forms; the equine drawing; the halo outside the
|
||||
drawing; every interactive surface declaring its stroke and capture. Browser pixels (Chromium 156, Firefox 157,
|
||||
WebKit 27.2; PDF raster as `browserRasterizer`, canvas inline): the equine views identical before and after (0 px), the
|
||||
markers under nine hostile roots identical to the plain markers (0 px) where `958228a` drew them altered (4 700 to
|
||||
196 000 px) or not at all (`opacity`, `display`). Real PDF exports (demo, v2full, v2unresolved, Chromium rasters): byte-
|
||||
identical to `958228a`. Clicks (`e2e/ui/canvas-clicks.spec.ts`): 67 pass on Chromium desktop and phone, Firefox, WebKit
|
||||
desktop and phone; on `958228a` 45 fail. Mutations I1 to I7 killed, K1, K7, K8, K10, V1, V6, V7 rerun killed.
|
||||
|
||||
Census and browser probe (owner brief 2026-11-01, « Lot B : approuvé »): `svg_marker_isolation::
|
||||
nothing_the_reader_keeps_changes_the_layer_or_the_halo` sets each of the reader's 77 allowed attributes (`sanitize::
|
||||
ALLOWED_ATTRIBUTES`, structural ones aside) on the root and on a descendant group, and 17 descendant `style` values,
|
||||
including CSS that acts outside its subtree in an HTML page (`z-index` with `position`, `position:fixed`, `mix-blend-mode`
|
||||
with `isolation`, `view-transition-name`, a 4 000 px `outline`, `contain`, `translate` in depth, anchor positioning,
|
||||
`pointer-events`); the layer and the halo serialise byte for byte as with a plain drawing, the root carries only
|
||||
namespaces and the frame. In the browser (Chromium 156, Firefox 157, WebKit 27.2, canvas inline and PDF raster), an opaque
|
||||
magenta rectangle covering the whole frame, last child of the equine drawing, carrying 21 candidate styles (15 kept by the reader; 6 with a function call,
|
||||
`transform:translateZ(…)`, `scale(…)`, `filter:drop-shadow(…)`, `backdrop-filter`, `clip-path:inset(…)`, `mask-image`,
|
||||
removed by it): the magenta pixel
|
||||
count equals the unstyled rectangle's inside the frame (the huge stroke and the outline only cover the anti-aliased edge
|
||||
rows) and the 13 points keep their click; the positive control (the same rectangle placed after the layer) covers every
|
||||
pixel and takes 0 of 13 clicks. Tools: `.claude/audits/2026-11-01-v1-2-2-decisions-tools/`.
|
||||
|
||||
References (owner brief 2026-11-01, « Références historiques : modification contrôlée autorisée »). The frozen files are
|
||||
not edited; the tests apply the declared transform to their frozen side and compare strictly:
|
||||
|
||||
| Reference | Transform | Where |
|
||||
|---|---|---|
|
||||
| R3 highlight oracle `crates/core/tests/oracles/r3/highlight.json` (36 cases) | `with_isolated_layer`: the root keeps `xmlns`, `xmlns:xlink`, `viewBox`; its other attributes and every child before the layer go into a `<g>`; `filter#osteo-halo` leaves the drawing for an engine `<defs>` placed before the layer; each point hitbox (circle, `pointer-events="all"`, no `stroke`) gets `stroke="none"` and `pointer-events="visibleFill"` | `tests/common/svg_tree.rs`, `anatomy_compose.rs`, `anatomy_canvas_op.rs` |
|
||||
| R3 canvas goldens `apps/app/tests/fixtures/goldens/r3/canvas.{main,head}.json` | `withIsolatedLayer`, the same rules on the mounted canvas tree | `tests/helpers/svgTree.ts`, `canvas.trees.test.tsx` |
|
||||
| R3 layer goldens `canvas.{main,head}.layers.json` | `withDeclaredHitboxes`: the hitbox rule alone | same |
|
||||
| R4.1 real-raster manifest `apps/app/tests/fixtures/pdf/r3/real/manifest.json`, call 1 `svgSha256` | edited, the one byte digest no transform can map: `a9a3155c…2c11` → `45fd4aaf…fc7f`; call 2 unchanged; `pdf-export.session.test.ts` green on all calls | the manifest (original in Git history, `87b8873`) |
|
||||
|
||||
Unchanged and still compared as frozen: R3 `layer.json` and `sanitiser.json`, the R4 PDF digests, the step6 goldens, the
|
||||
N-1 copies, the seed review drawings (R3 layer kept for them), the equine drawing (sha256 `0ea5202f…`) and its fingerprint.
|
||||
The equine renders identically before and after (0 px, three engines, canvas and PDF), and the real PDF exports are
|
||||
byte-identical to `958228a`. Correction to §12.10: the class fix does not change the R4 digests; only the R4.1 call-1
|
||||
`svgSha256` changes.
|
||||
|
||||
Open, pre-existing, owner decision: the vertebral junction points sit on the edge of zones painted and hit after them;
|
||||
measured in all three engines on the plain equine sheet, 28 to 49 % of `c7-t1`, `l6-s1` and `t18-l1`'s visible disc
|
||||
records the zone, 8 % of the fore fetlock's records the fore sesamoids (`fixme` in the click spec).
|
||||
Reference in new issue
Block a user